From 336827433e8e3c14d71b938023a6762a9b537771 Mon Sep 17 00:00:00 2001 From: syui Date: Thu, 11 Apr 2024 06:11:26 +0900 Subject: [PATCH] add seven --- ent/client.go | 182 +- ent/ent.go | 2 + ent/hook/hook.go | 12 + ent/migrate/schema.go | 35 +- ent/mutation.go | 1463 +++++++++++- ent/ogent/oas_client_gen.go | 630 +++++ ent/ogent/oas_handlers_gen.go | 741 ++++++ ent/ogent/oas_interfaces_gen.go | 28 + ent/ogent/oas_json_gen.go | 2960 +++++++++++++++++++++++- ent/ogent/oas_parameters_gen.go | 580 +++++ ent/ogent/oas_request_decoders_gen.go | 126 + ent/ogent/oas_request_encoders_gen.go | 28 + ent/ogent/oas_response_decoders_gen.go | 1200 ++++++++++ ent/ogent/oas_response_encoders_gen.go | 456 ++++ ent/ogent/oas_router_gen.go | 215 ++ ent/ogent/oas_schemas_gen.go | 1508 ++++++++++++ ent/ogent/oas_server_gen.go | 42 + ent/ogent/oas_unimplemented_gen.go | 63 + ent/ogent/oas_validators_gen.go | 12 + ent/ogent/ogent.go | 307 +++ ent/ogent/responses.go | 260 +++ ent/openapi.json | 878 +++++++ ent/predicate/predicate.go | 3 + ent/runtime.go | 15 + ent/schema/seven.go | 71 + ent/schema/user.go | 1 + ent/sev.go | 268 +++ ent/sev/sev.go | 181 ++ ent/sev/where.go | 831 +++++++ ent/sev_create.go | 429 ++++ ent/sev_delete.go | 88 + ent/sev_query.go | 613 +++++ ent/sev_update.go | 917 ++++++++ ent/tx.go | 3 + ent/user.go | 18 +- ent/user/user.go | 30 + ent/user/where.go | 23 + ent/user_create.go | 32 + ent/user_query.go | 77 +- ent/user_update.go | 163 ++ tmp/ogent/oas_response_encoders_gen.go | 456 ++++ tmp/ogent/ogent.go | 307 +++ 42 files changed, 16234 insertions(+), 20 deletions(-) create mode 100644 ent/schema/seven.go create mode 100644 ent/sev.go create mode 100644 ent/sev/sev.go create mode 100644 ent/sev/where.go create mode 100644 ent/sev_create.go create mode 100644 ent/sev_delete.go create mode 100644 ent/sev_query.go create mode 100644 ent/sev_update.go diff --git a/ent/client.go b/ent/client.go index 582cebc..2120a20 100644 --- a/ent/client.go +++ b/ent/client.go @@ -13,6 +13,7 @@ import ( "api/ent/card" "api/ent/group" "api/ent/ma" + "api/ent/sev" "api/ent/ue" "api/ent/user" @@ -33,6 +34,8 @@ type Client struct { Group *GroupClient // Ma is the client for interacting with the Ma builders. Ma *MaClient + // Sev is the client for interacting with the Sev builders. + Sev *SevClient // Ue is the client for interacting with the Ue builders. Ue *UeClient // User is the client for interacting with the User builders. @@ -53,6 +56,7 @@ func (c *Client) init() { c.Card = NewCardClient(c.config) c.Group = NewGroupClient(c.config) c.Ma = NewMaClient(c.config) + c.Sev = NewSevClient(c.config) c.Ue = NewUeClient(c.config) c.User = NewUserClient(c.config) } @@ -140,6 +144,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) { Card: NewCardClient(cfg), Group: NewGroupClient(cfg), Ma: NewMaClient(cfg), + Sev: NewSevClient(cfg), Ue: NewUeClient(cfg), User: NewUserClient(cfg), }, nil @@ -164,6 +169,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) Card: NewCardClient(cfg), Group: NewGroupClient(cfg), Ma: NewMaClient(cfg), + Sev: NewSevClient(cfg), Ue: NewUeClient(cfg), User: NewUserClient(cfg), }, nil @@ -194,21 +200,21 @@ func (c *Client) Close() error { // Use adds the mutation hooks to all the entity clients. // In order to add hooks to a specific client, call: `client.Node.Use(...)`. func (c *Client) Use(hooks ...Hook) { - c.Card.Use(hooks...) - c.Group.Use(hooks...) - c.Ma.Use(hooks...) - c.Ue.Use(hooks...) - c.User.Use(hooks...) + for _, n := range []interface{ Use(...Hook) }{ + c.Card, c.Group, c.Ma, c.Sev, c.Ue, c.User, + } { + n.Use(hooks...) + } } // Intercept adds the query interceptors to all the entity clients. // In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`. func (c *Client) Intercept(interceptors ...Interceptor) { - c.Card.Intercept(interceptors...) - c.Group.Intercept(interceptors...) - c.Ma.Intercept(interceptors...) - c.Ue.Intercept(interceptors...) - c.User.Intercept(interceptors...) + for _, n := range []interface{ Intercept(...Interceptor) }{ + c.Card, c.Group, c.Ma, c.Sev, c.Ue, c.User, + } { + n.Intercept(interceptors...) + } } // Mutate implements the ent.Mutator interface. @@ -220,6 +226,8 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) { return c.Group.mutate(ctx, m) case *MaMutation: return c.Ma.mutate(ctx, m) + case *SevMutation: + return c.Sev.mutate(ctx, m) case *UeMutation: return c.Ue.mutate(ctx, m) case *UserMutation: @@ -631,6 +639,140 @@ func (c *MaClient) mutate(ctx context.Context, m *MaMutation) (Value, error) { } } +// SevClient is a client for the Sev schema. +type SevClient struct { + config +} + +// NewSevClient returns a client for the Sev from the given config. +func NewSevClient(c config) *SevClient { + return &SevClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `sev.Hooks(f(g(h())))`. +func (c *SevClient) Use(hooks ...Hook) { + c.hooks.Sev = append(c.hooks.Sev, hooks...) +} + +// Intercept adds a list of query interceptors to the interceptors stack. +// A call to `Intercept(f, g, h)` equals to `sev.Intercept(f(g(h())))`. +func (c *SevClient) Intercept(interceptors ...Interceptor) { + c.inters.Sev = append(c.inters.Sev, interceptors...) +} + +// Create returns a builder for creating a Sev entity. +func (c *SevClient) Create() *SevCreate { + mutation := newSevMutation(c.config, OpCreate) + return &SevCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of Sev entities. +func (c *SevClient) CreateBulk(builders ...*SevCreate) *SevCreateBulk { + return &SevCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for Sev. +func (c *SevClient) Update() *SevUpdate { + mutation := newSevMutation(c.config, OpUpdate) + return &SevUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *SevClient) UpdateOne(s *Sev) *SevUpdateOne { + mutation := newSevMutation(c.config, OpUpdateOne, withSev(s)) + return &SevUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *SevClient) UpdateOneID(id int) *SevUpdateOne { + mutation := newSevMutation(c.config, OpUpdateOne, withSevID(id)) + return &SevUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for Sev. +func (c *SevClient) Delete() *SevDelete { + mutation := newSevMutation(c.config, OpDelete) + return &SevDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *SevClient) DeleteOne(s *Sev) *SevDeleteOne { + return c.DeleteOneID(s.ID) +} + +// DeleteOneID returns a builder for deleting the given entity by its id. +func (c *SevClient) DeleteOneID(id int) *SevDeleteOne { + builder := c.Delete().Where(sev.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &SevDeleteOne{builder} +} + +// Query returns a query builder for Sev. +func (c *SevClient) Query() *SevQuery { + return &SevQuery{ + config: c.config, + ctx: &QueryContext{Type: TypeSev}, + inters: c.Interceptors(), + } +} + +// Get returns a Sev entity by its id. +func (c *SevClient) Get(ctx context.Context, id int) (*Sev, error) { + return c.Query().Where(sev.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *SevClient) GetX(ctx context.Context, id int) *Sev { + obj, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return obj +} + +// QueryOwner queries the owner edge of a Sev. +func (c *SevClient) QueryOwner(s *Sev) *UserQuery { + query := (&UserClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := s.ID + step := sqlgraph.NewStep( + sqlgraph.From(sev.Table, sev.FieldID, id), + sqlgraph.To(user.Table, user.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, sev.OwnerTable, sev.OwnerColumn), + ) + fromV = sqlgraph.Neighbors(s.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// Hooks returns the client hooks. +func (c *SevClient) Hooks() []Hook { + return c.hooks.Sev +} + +// Interceptors returns the client interceptors. +func (c *SevClient) Interceptors() []Interceptor { + return c.inters.Sev +} + +func (c *SevClient) mutate(ctx context.Context, m *SevMutation) (Value, error) { + switch m.Op() { + case OpCreate: + return (&SevCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdate: + return (&SevUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdateOne: + return (&SevUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpDelete, OpDeleteOne: + return (&SevDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx) + default: + return nil, fmt.Errorf("ent: unknown Sev mutation op: %q", m.Op()) + } +} + // UeClient is a client for the Ue schema. type UeClient struct { config @@ -906,6 +1048,22 @@ func (c *UserClient) QueryMa(u *User) *MaQuery { return query } +// QuerySev queries the sev edge of a User. +func (c *UserClient) QuerySev(u *User) *SevQuery { + query := (&SevClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := u.ID + step := sqlgraph.NewStep( + sqlgraph.From(user.Table, user.FieldID, id), + sqlgraph.To(sev.Table, sev.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, user.SevTable, user.SevColumn), + ) + fromV = sqlgraph.Neighbors(u.driver.Dialect(), step) + return fromV, nil + } + return query +} + // Hooks returns the client hooks. func (c *UserClient) Hooks() []Hook { return c.hooks.User @@ -934,9 +1092,9 @@ func (c *UserClient) mutate(ctx context.Context, m *UserMutation) (Value, error) // hooks and interceptors per client, for fast access. type ( hooks struct { - Card, Group, Ma, Ue, User []ent.Hook + Card, Group, Ma, Sev, Ue, User []ent.Hook } inters struct { - Card, Group, Ma, Ue, User []ent.Interceptor + Card, Group, Ma, Sev, Ue, User []ent.Interceptor } ) diff --git a/ent/ent.go b/ent/ent.go index f91e530..acaea08 100644 --- a/ent/ent.go +++ b/ent/ent.go @@ -6,6 +6,7 @@ import ( "api/ent/card" "api/ent/group" "api/ent/ma" + "api/ent/sev" "api/ent/ue" "api/ent/user" "context" @@ -80,6 +81,7 @@ func checkColumn(table, column string) error { card.Table: card.ValidColumn, group.Table: group.ValidColumn, ma.Table: ma.ValidColumn, + sev.Table: sev.ValidColumn, ue.Table: ue.ValidColumn, user.Table: user.ValidColumn, }) diff --git a/ent/hook/hook.go b/ent/hook/hook.go index c4e9057..70d3565 100644 --- a/ent/hook/hook.go +++ b/ent/hook/hook.go @@ -44,6 +44,18 @@ func (f MaFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MaMutation", m) } +// The SevFunc type is an adapter to allow the use of ordinary +// function as Sev mutator. +type SevFunc func(context.Context, *ent.SevMutation) (ent.Value, error) + +// Mutate calls f(ctx, m). +func (f SevFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { + if mv, ok := m.(*ent.SevMutation); ok { + return f(ctx, mv) + } + return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.SevMutation", m) +} + // The UeFunc type is an adapter to allow the use of ordinary // function as Ue mutator. type UeFunc func(context.Context, *ent.UeMutation) (ent.Value, error) diff --git a/ent/migrate/schema.go b/ent/migrate/schema.go index 5f46470..2c99506 100644 --- a/ent/migrate/schema.go +++ b/ent/migrate/schema.go @@ -89,6 +89,37 @@ var ( }, }, } + // SevsColumns holds the columns for the "sevs" table. + SevsColumns = []*schema.Column{ + {Name: "id", Type: field.TypeInt, Increment: true}, + {Name: "password", Type: field.TypeString}, + {Name: "token", Type: field.TypeString, Nullable: true}, + {Name: "limit", Type: field.TypeBool, Nullable: true, Default: false}, + {Name: "count", Type: field.TypeInt, Nullable: true}, + {Name: "handle", Type: field.TypeString, Nullable: true}, + {Name: "did", Type: field.TypeString, Nullable: true}, + {Name: "uid", Type: field.TypeInt, Nullable: true}, + {Name: "cid", Type: field.TypeInt, Nullable: true}, + {Name: "cp", Type: field.TypeInt, Nullable: true}, + {Name: "card", Type: field.TypeInt, Nullable: true}, + {Name: "updated_at", Type: field.TypeTime, Nullable: true}, + {Name: "created_at", Type: field.TypeTime, Nullable: true}, + {Name: "user_sev", Type: field.TypeInt}, + } + // SevsTable holds the schema information for the "sevs" table. + SevsTable = &schema.Table{ + Name: "sevs", + Columns: SevsColumns, + PrimaryKey: []*schema.Column{SevsColumns[0]}, + ForeignKeys: []*schema.ForeignKey{ + { + Symbol: "sevs_users_sev", + Columns: []*schema.Column{SevsColumns[13]}, + RefColumns: []*schema.Column{UsersColumns[0]}, + OnDelete: schema.NoAction, + }, + }, + } // UesColumns holds the columns for the "ues" table. UesColumns = []*schema.Column{ {Name: "id", Type: field.TypeInt, Increment: true}, @@ -162,7 +193,7 @@ var ( {Name: "ten_post", Type: field.TypeString, Nullable: true}, {Name: "ten_get", Type: field.TypeString, Nullable: true}, {Name: "ten_at", Type: field.TypeTime, Nullable: true}, - {Name: "next", Type: field.TypeString, Nullable: true, Default: "20240401"}, + {Name: "next", Type: field.TypeString, Nullable: true, Default: "20240410"}, {Name: "room", Type: field.TypeInt, Nullable: true}, {Name: "model", Type: field.TypeBool, Nullable: true}, {Name: "model_at", Type: field.TypeTime, Nullable: true}, @@ -208,6 +239,7 @@ var ( CardsTable, GroupsTable, MasTable, + SevsTable, UesTable, UsersTable, } @@ -216,6 +248,7 @@ var ( func init() { CardsTable.ForeignKeys[0].RefTable = UsersTable MasTable.ForeignKeys[0].RefTable = UsersTable + SevsTable.ForeignKeys[0].RefTable = UsersTable UesTable.ForeignKeys[0].RefTable = UsersTable UsersTable.ForeignKeys[0].RefTable = GroupsTable } diff --git a/ent/mutation.go b/ent/mutation.go index 5579bb8..761e692 100644 --- a/ent/mutation.go +++ b/ent/mutation.go @@ -7,6 +7,7 @@ import ( "api/ent/group" "api/ent/ma" "api/ent/predicate" + "api/ent/sev" "api/ent/ue" "api/ent/user" "context" @@ -31,6 +32,7 @@ const ( TypeCard = "Card" TypeGroup = "Group" TypeMa = "Ma" + TypeSev = "Sev" TypeUe = "Ue" TypeUser = "User" ) @@ -3048,6 +3050,1378 @@ func (m *MaMutation) ResetEdge(name string) error { return fmt.Errorf("unknown Ma edge %s", name) } +// SevMutation represents an operation that mutates the Sev nodes in the graph. +type SevMutation struct { + config + op Op + typ string + id *int + password *string + token *string + _limit *bool + count *int + addcount *int + handle *string + did *string + uid *int + adduid *int + cid *int + addcid *int + cp *int + addcp *int + card *int + addcard *int + updated_at *time.Time + created_at *time.Time + clearedFields map[string]struct{} + owner *int + clearedowner bool + done bool + oldValue func(context.Context) (*Sev, error) + predicates []predicate.Sev +} + +var _ ent.Mutation = (*SevMutation)(nil) + +// sevOption allows management of the mutation configuration using functional options. +type sevOption func(*SevMutation) + +// newSevMutation creates new mutation for the Sev entity. +func newSevMutation(c config, op Op, opts ...sevOption) *SevMutation { + m := &SevMutation{ + config: c, + op: op, + typ: TypeSev, + clearedFields: make(map[string]struct{}), + } + for _, opt := range opts { + opt(m) + } + return m +} + +// withSevID sets the ID field of the mutation. +func withSevID(id int) sevOption { + return func(m *SevMutation) { + var ( + err error + once sync.Once + value *Sev + ) + m.oldValue = func(ctx context.Context) (*Sev, error) { + once.Do(func() { + if m.done { + err = errors.New("querying old values post mutation is not allowed") + } else { + value, err = m.Client().Sev.Get(ctx, id) + } + }) + return value, err + } + m.id = &id + } +} + +// withSev sets the old Sev of the mutation. +func withSev(node *Sev) sevOption { + return func(m *SevMutation) { + m.oldValue = func(context.Context) (*Sev, 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 SevMutation) 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 SevMutation) 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 *SevMutation) 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 *SevMutation) 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().Sev.Query().Where(m.predicates...).IDs(ctx) + default: + return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op) + } +} + +// SetPassword sets the "password" field. +func (m *SevMutation) SetPassword(s string) { + m.password = &s +} + +// Password returns the value of the "password" field in the mutation. +func (m *SevMutation) Password() (r string, exists bool) { + v := m.password + if v == nil { + return + } + return *v, true +} + +// OldPassword returns the old "password" field's value of the Sev entity. +// If the Sev 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 *SevMutation) OldPassword(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldPassword is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldPassword requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldPassword: %w", err) + } + return oldValue.Password, nil +} + +// ResetPassword resets all changes to the "password" field. +func (m *SevMutation) ResetPassword() { + m.password = nil +} + +// SetToken sets the "token" field. +func (m *SevMutation) SetToken(s string) { + m.token = &s +} + +// Token returns the value of the "token" field in the mutation. +func (m *SevMutation) Token() (r string, exists bool) { + v := m.token + if v == nil { + return + } + return *v, true +} + +// OldToken returns the old "token" field's value of the Sev entity. +// If the Sev 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 *SevMutation) OldToken(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldToken is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldToken requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldToken: %w", err) + } + return oldValue.Token, nil +} + +// ClearToken clears the value of the "token" field. +func (m *SevMutation) ClearToken() { + m.token = nil + m.clearedFields[sev.FieldToken] = struct{}{} +} + +// TokenCleared returns if the "token" field was cleared in this mutation. +func (m *SevMutation) TokenCleared() bool { + _, ok := m.clearedFields[sev.FieldToken] + return ok +} + +// ResetToken resets all changes to the "token" field. +func (m *SevMutation) ResetToken() { + m.token = nil + delete(m.clearedFields, sev.FieldToken) +} + +// SetLimit sets the "limit" field. +func (m *SevMutation) SetLimit(b bool) { + m._limit = &b +} + +// Limit returns the value of the "limit" field in the mutation. +func (m *SevMutation) Limit() (r bool, exists bool) { + v := m._limit + if v == nil { + return + } + return *v, true +} + +// OldLimit returns the old "limit" field's value of the Sev entity. +// If the Sev 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 *SevMutation) OldLimit(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldLimit is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldLimit requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldLimit: %w", err) + } + return oldValue.Limit, nil +} + +// ClearLimit clears the value of the "limit" field. +func (m *SevMutation) ClearLimit() { + m._limit = nil + m.clearedFields[sev.FieldLimit] = struct{}{} +} + +// LimitCleared returns if the "limit" field was cleared in this mutation. +func (m *SevMutation) LimitCleared() bool { + _, ok := m.clearedFields[sev.FieldLimit] + return ok +} + +// ResetLimit resets all changes to the "limit" field. +func (m *SevMutation) ResetLimit() { + m._limit = nil + delete(m.clearedFields, sev.FieldLimit) +} + +// SetCount sets the "count" field. +func (m *SevMutation) SetCount(i int) { + m.count = &i + m.addcount = nil +} + +// Count returns the value of the "count" field in the mutation. +func (m *SevMutation) Count() (r int, exists bool) { + v := m.count + if v == nil { + return + } + return *v, true +} + +// OldCount returns the old "count" field's value of the Sev entity. +// If the Sev 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 *SevMutation) OldCount(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCount is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCount requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCount: %w", err) + } + return oldValue.Count, nil +} + +// AddCount adds i to the "count" field. +func (m *SevMutation) AddCount(i int) { + if m.addcount != nil { + *m.addcount += i + } else { + m.addcount = &i + } +} + +// AddedCount returns the value that was added to the "count" field in this mutation. +func (m *SevMutation) AddedCount() (r int, exists bool) { + v := m.addcount + if v == nil { + return + } + return *v, true +} + +// ClearCount clears the value of the "count" field. +func (m *SevMutation) ClearCount() { + m.count = nil + m.addcount = nil + m.clearedFields[sev.FieldCount] = struct{}{} +} + +// CountCleared returns if the "count" field was cleared in this mutation. +func (m *SevMutation) CountCleared() bool { + _, ok := m.clearedFields[sev.FieldCount] + return ok +} + +// ResetCount resets all changes to the "count" field. +func (m *SevMutation) ResetCount() { + m.count = nil + m.addcount = nil + delete(m.clearedFields, sev.FieldCount) +} + +// SetHandle sets the "handle" field. +func (m *SevMutation) SetHandle(s string) { + m.handle = &s +} + +// Handle returns the value of the "handle" field in the mutation. +func (m *SevMutation) Handle() (r string, exists bool) { + v := m.handle + if v == nil { + return + } + return *v, true +} + +// OldHandle returns the old "handle" field's value of the Sev entity. +// If the Sev 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 *SevMutation) OldHandle(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldHandle is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldHandle requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldHandle: %w", err) + } + return oldValue.Handle, nil +} + +// ClearHandle clears the value of the "handle" field. +func (m *SevMutation) ClearHandle() { + m.handle = nil + m.clearedFields[sev.FieldHandle] = struct{}{} +} + +// HandleCleared returns if the "handle" field was cleared in this mutation. +func (m *SevMutation) HandleCleared() bool { + _, ok := m.clearedFields[sev.FieldHandle] + return ok +} + +// ResetHandle resets all changes to the "handle" field. +func (m *SevMutation) ResetHandle() { + m.handle = nil + delete(m.clearedFields, sev.FieldHandle) +} + +// SetDid sets the "did" field. +func (m *SevMutation) SetDid(s string) { + m.did = &s +} + +// Did returns the value of the "did" field in the mutation. +func (m *SevMutation) Did() (r string, exists bool) { + v := m.did + if v == nil { + return + } + return *v, true +} + +// OldDid returns the old "did" field's value of the Sev entity. +// If the Sev 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 *SevMutation) OldDid(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldDid is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldDid requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldDid: %w", err) + } + return oldValue.Did, nil +} + +// ClearDid clears the value of the "did" field. +func (m *SevMutation) ClearDid() { + m.did = nil + m.clearedFields[sev.FieldDid] = struct{}{} +} + +// DidCleared returns if the "did" field was cleared in this mutation. +func (m *SevMutation) DidCleared() bool { + _, ok := m.clearedFields[sev.FieldDid] + return ok +} + +// ResetDid resets all changes to the "did" field. +func (m *SevMutation) ResetDid() { + m.did = nil + delete(m.clearedFields, sev.FieldDid) +} + +// SetUID sets the "uid" field. +func (m *SevMutation) SetUID(i int) { + m.uid = &i + m.adduid = nil +} + +// UID returns the value of the "uid" field in the mutation. +func (m *SevMutation) UID() (r int, exists bool) { + v := m.uid + if v == nil { + return + } + return *v, true +} + +// OldUID returns the old "uid" field's value of the Sev entity. +// If the Sev 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 *SevMutation) OldUID(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUID: %w", err) + } + return oldValue.UID, nil +} + +// AddUID adds i to the "uid" field. +func (m *SevMutation) AddUID(i int) { + if m.adduid != nil { + *m.adduid += i + } else { + m.adduid = &i + } +} + +// AddedUID returns the value that was added to the "uid" field in this mutation. +func (m *SevMutation) AddedUID() (r int, exists bool) { + v := m.adduid + if v == nil { + return + } + return *v, true +} + +// ClearUID clears the value of the "uid" field. +func (m *SevMutation) ClearUID() { + m.uid = nil + m.adduid = nil + m.clearedFields[sev.FieldUID] = struct{}{} +} + +// UIDCleared returns if the "uid" field was cleared in this mutation. +func (m *SevMutation) UIDCleared() bool { + _, ok := m.clearedFields[sev.FieldUID] + return ok +} + +// ResetUID resets all changes to the "uid" field. +func (m *SevMutation) ResetUID() { + m.uid = nil + m.adduid = nil + delete(m.clearedFields, sev.FieldUID) +} + +// SetCid sets the "cid" field. +func (m *SevMutation) SetCid(i int) { + m.cid = &i + m.addcid = nil +} + +// Cid returns the value of the "cid" field in the mutation. +func (m *SevMutation) Cid() (r int, exists bool) { + v := m.cid + if v == nil { + return + } + return *v, true +} + +// OldCid returns the old "cid" field's value of the Sev entity. +// If the Sev 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 *SevMutation) OldCid(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCid is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCid requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCid: %w", err) + } + return oldValue.Cid, nil +} + +// AddCid adds i to the "cid" field. +func (m *SevMutation) AddCid(i int) { + if m.addcid != nil { + *m.addcid += i + } else { + m.addcid = &i + } +} + +// AddedCid returns the value that was added to the "cid" field in this mutation. +func (m *SevMutation) AddedCid() (r int, exists bool) { + v := m.addcid + if v == nil { + return + } + return *v, true +} + +// ClearCid clears the value of the "cid" field. +func (m *SevMutation) ClearCid() { + m.cid = nil + m.addcid = nil + m.clearedFields[sev.FieldCid] = struct{}{} +} + +// CidCleared returns if the "cid" field was cleared in this mutation. +func (m *SevMutation) CidCleared() bool { + _, ok := m.clearedFields[sev.FieldCid] + return ok +} + +// ResetCid resets all changes to the "cid" field. +func (m *SevMutation) ResetCid() { + m.cid = nil + m.addcid = nil + delete(m.clearedFields, sev.FieldCid) +} + +// SetCp sets the "cp" field. +func (m *SevMutation) SetCp(i int) { + m.cp = &i + m.addcp = nil +} + +// Cp returns the value of the "cp" field in the mutation. +func (m *SevMutation) Cp() (r int, exists bool) { + v := m.cp + if v == nil { + return + } + return *v, true +} + +// OldCp returns the old "cp" field's value of the Sev entity. +// If the Sev 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 *SevMutation) OldCp(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCp is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCp requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCp: %w", err) + } + return oldValue.Cp, nil +} + +// AddCp adds i to the "cp" field. +func (m *SevMutation) AddCp(i int) { + if m.addcp != nil { + *m.addcp += i + } else { + m.addcp = &i + } +} + +// AddedCp returns the value that was added to the "cp" field in this mutation. +func (m *SevMutation) AddedCp() (r int, exists bool) { + v := m.addcp + if v == nil { + return + } + return *v, true +} + +// ClearCp clears the value of the "cp" field. +func (m *SevMutation) ClearCp() { + m.cp = nil + m.addcp = nil + m.clearedFields[sev.FieldCp] = struct{}{} +} + +// CpCleared returns if the "cp" field was cleared in this mutation. +func (m *SevMutation) CpCleared() bool { + _, ok := m.clearedFields[sev.FieldCp] + return ok +} + +// ResetCp resets all changes to the "cp" field. +func (m *SevMutation) ResetCp() { + m.cp = nil + m.addcp = nil + delete(m.clearedFields, sev.FieldCp) +} + +// SetCard sets the "card" field. +func (m *SevMutation) SetCard(i int) { + m.card = &i + m.addcard = nil +} + +// Card returns the value of the "card" field in the mutation. +func (m *SevMutation) Card() (r int, exists bool) { + v := m.card + if v == nil { + return + } + return *v, true +} + +// OldCard returns the old "card" field's value of the Sev entity. +// If the Sev 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 *SevMutation) OldCard(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCard is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCard requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCard: %w", err) + } + return oldValue.Card, nil +} + +// AddCard adds i to the "card" field. +func (m *SevMutation) AddCard(i int) { + if m.addcard != nil { + *m.addcard += i + } else { + m.addcard = &i + } +} + +// AddedCard returns the value that was added to the "card" field in this mutation. +func (m *SevMutation) AddedCard() (r int, exists bool) { + v := m.addcard + if v == nil { + return + } + return *v, true +} + +// ClearCard clears the value of the "card" field. +func (m *SevMutation) ClearCard() { + m.card = nil + m.addcard = nil + m.clearedFields[sev.FieldCard] = struct{}{} +} + +// CardCleared returns if the "card" field was cleared in this mutation. +func (m *SevMutation) CardCleared() bool { + _, ok := m.clearedFields[sev.FieldCard] + return ok +} + +// ResetCard resets all changes to the "card" field. +func (m *SevMutation) ResetCard() { + m.card = nil + m.addcard = nil + delete(m.clearedFields, sev.FieldCard) +} + +// SetUpdatedAt sets the "updated_at" field. +func (m *SevMutation) SetUpdatedAt(t time.Time) { + m.updated_at = &t +} + +// UpdatedAt returns the value of the "updated_at" field in the mutation. +func (m *SevMutation) 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 Sev entity. +// If the Sev 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 *SevMutation) 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 +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (m *SevMutation) ClearUpdatedAt() { + m.updated_at = nil + m.clearedFields[sev.FieldUpdatedAt] = struct{}{} +} + +// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation. +func (m *SevMutation) UpdatedAtCleared() bool { + _, ok := m.clearedFields[sev.FieldUpdatedAt] + return ok +} + +// ResetUpdatedAt resets all changes to the "updated_at" field. +func (m *SevMutation) ResetUpdatedAt() { + m.updated_at = nil + delete(m.clearedFields, sev.FieldUpdatedAt) +} + +// SetCreatedAt sets the "created_at" field. +func (m *SevMutation) SetCreatedAt(t time.Time) { + m.created_at = &t +} + +// CreatedAt returns the value of the "created_at" field in the mutation. +func (m *SevMutation) 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 Sev entity. +// If the Sev 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 *SevMutation) 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 +} + +// ClearCreatedAt clears the value of the "created_at" field. +func (m *SevMutation) ClearCreatedAt() { + m.created_at = nil + m.clearedFields[sev.FieldCreatedAt] = struct{}{} +} + +// CreatedAtCleared returns if the "created_at" field was cleared in this mutation. +func (m *SevMutation) CreatedAtCleared() bool { + _, ok := m.clearedFields[sev.FieldCreatedAt] + return ok +} + +// ResetCreatedAt resets all changes to the "created_at" field. +func (m *SevMutation) ResetCreatedAt() { + m.created_at = nil + delete(m.clearedFields, sev.FieldCreatedAt) +} + +// SetOwnerID sets the "owner" edge to the User entity by id. +func (m *SevMutation) SetOwnerID(id int) { + m.owner = &id +} + +// ClearOwner clears the "owner" edge to the User entity. +func (m *SevMutation) ClearOwner() { + m.clearedowner = true +} + +// OwnerCleared reports if the "owner" edge to the User entity was cleared. +func (m *SevMutation) OwnerCleared() bool { + return m.clearedowner +} + +// OwnerID returns the "owner" edge ID in the mutation. +func (m *SevMutation) 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 *SevMutation) OwnerIDs() (ids []int) { + if id := m.owner; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetOwner resets all changes to the "owner" edge. +func (m *SevMutation) ResetOwner() { + m.owner = nil + m.clearedowner = false +} + +// Where appends a list predicates to the SevMutation builder. +func (m *SevMutation) Where(ps ...predicate.Sev) { + m.predicates = append(m.predicates, ps...) +} + +// WhereP appends storage-level predicates to the SevMutation builder. Using this method, +// users can use type-assertion to append predicates that do not depend on any generated package. +func (m *SevMutation) WhereP(ps ...func(*sql.Selector)) { + p := make([]predicate.Sev, len(ps)) + for i := range ps { + p[i] = ps[i] + } + m.Where(p...) +} + +// Op returns the operation name. +func (m *SevMutation) Op() Op { + return m.op +} + +// SetOp allows setting the mutation operation. +func (m *SevMutation) SetOp(op Op) { + m.op = op +} + +// Type returns the node type of this mutation (Sev). +func (m *SevMutation) 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 *SevMutation) Fields() []string { + fields := make([]string, 0, 12) + if m.password != nil { + fields = append(fields, sev.FieldPassword) + } + if m.token != nil { + fields = append(fields, sev.FieldToken) + } + if m._limit != nil { + fields = append(fields, sev.FieldLimit) + } + if m.count != nil { + fields = append(fields, sev.FieldCount) + } + if m.handle != nil { + fields = append(fields, sev.FieldHandle) + } + if m.did != nil { + fields = append(fields, sev.FieldDid) + } + if m.uid != nil { + fields = append(fields, sev.FieldUID) + } + if m.cid != nil { + fields = append(fields, sev.FieldCid) + } + if m.cp != nil { + fields = append(fields, sev.FieldCp) + } + if m.card != nil { + fields = append(fields, sev.FieldCard) + } + if m.updated_at != nil { + fields = append(fields, sev.FieldUpdatedAt) + } + if m.created_at != nil { + fields = append(fields, sev.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 *SevMutation) Field(name string) (ent.Value, bool) { + switch name { + case sev.FieldPassword: + return m.Password() + case sev.FieldToken: + return m.Token() + case sev.FieldLimit: + return m.Limit() + case sev.FieldCount: + return m.Count() + case sev.FieldHandle: + return m.Handle() + case sev.FieldDid: + return m.Did() + case sev.FieldUID: + return m.UID() + case sev.FieldCid: + return m.Cid() + case sev.FieldCp: + return m.Cp() + case sev.FieldCard: + return m.Card() + case sev.FieldUpdatedAt: + return m.UpdatedAt() + case sev.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 *SevMutation) OldField(ctx context.Context, name string) (ent.Value, error) { + switch name { + case sev.FieldPassword: + return m.OldPassword(ctx) + case sev.FieldToken: + return m.OldToken(ctx) + case sev.FieldLimit: + return m.OldLimit(ctx) + case sev.FieldCount: + return m.OldCount(ctx) + case sev.FieldHandle: + return m.OldHandle(ctx) + case sev.FieldDid: + return m.OldDid(ctx) + case sev.FieldUID: + return m.OldUID(ctx) + case sev.FieldCid: + return m.OldCid(ctx) + case sev.FieldCp: + return m.OldCp(ctx) + case sev.FieldCard: + return m.OldCard(ctx) + case sev.FieldUpdatedAt: + return m.OldUpdatedAt(ctx) + case sev.FieldCreatedAt: + return m.OldCreatedAt(ctx) + } + return nil, fmt.Errorf("unknown Sev 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 *SevMutation) SetField(name string, value ent.Value) error { + switch name { + case sev.FieldPassword: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetPassword(v) + return nil + case sev.FieldToken: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetToken(v) + return nil + case sev.FieldLimit: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetLimit(v) + return nil + case sev.FieldCount: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCount(v) + return nil + case sev.FieldHandle: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetHandle(v) + return nil + case sev.FieldDid: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetDid(v) + return nil + case sev.FieldUID: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUID(v) + return nil + case sev.FieldCid: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCid(v) + return nil + case sev.FieldCp: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCp(v) + return nil + case sev.FieldCard: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCard(v) + return nil + case sev.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 sev.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 Sev field %s", name) +} + +// AddedFields returns all numeric fields that were incremented/decremented during +// this mutation. +func (m *SevMutation) AddedFields() []string { + var fields []string + if m.addcount != nil { + fields = append(fields, sev.FieldCount) + } + if m.adduid != nil { + fields = append(fields, sev.FieldUID) + } + if m.addcid != nil { + fields = append(fields, sev.FieldCid) + } + if m.addcp != nil { + fields = append(fields, sev.FieldCp) + } + if m.addcard != nil { + fields = append(fields, sev.FieldCard) + } + 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 *SevMutation) AddedField(name string) (ent.Value, bool) { + switch name { + case sev.FieldCount: + return m.AddedCount() + case sev.FieldUID: + return m.AddedUID() + case sev.FieldCid: + return m.AddedCid() + case sev.FieldCp: + return m.AddedCp() + case sev.FieldCard: + return m.AddedCard() + } + 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 *SevMutation) AddField(name string, value ent.Value) error { + switch name { + case sev.FieldCount: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddCount(v) + return nil + case sev.FieldUID: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddUID(v) + return nil + case sev.FieldCid: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddCid(v) + return nil + case sev.FieldCp: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddCp(v) + return nil + case sev.FieldCard: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddCard(v) + return nil + } + return fmt.Errorf("unknown Sev numeric field %s", name) +} + +// ClearedFields returns all nullable fields that were cleared during this +// mutation. +func (m *SevMutation) ClearedFields() []string { + var fields []string + if m.FieldCleared(sev.FieldToken) { + fields = append(fields, sev.FieldToken) + } + if m.FieldCleared(sev.FieldLimit) { + fields = append(fields, sev.FieldLimit) + } + if m.FieldCleared(sev.FieldCount) { + fields = append(fields, sev.FieldCount) + } + if m.FieldCleared(sev.FieldHandle) { + fields = append(fields, sev.FieldHandle) + } + if m.FieldCleared(sev.FieldDid) { + fields = append(fields, sev.FieldDid) + } + if m.FieldCleared(sev.FieldUID) { + fields = append(fields, sev.FieldUID) + } + if m.FieldCleared(sev.FieldCid) { + fields = append(fields, sev.FieldCid) + } + if m.FieldCleared(sev.FieldCp) { + fields = append(fields, sev.FieldCp) + } + if m.FieldCleared(sev.FieldCard) { + fields = append(fields, sev.FieldCard) + } + if m.FieldCleared(sev.FieldUpdatedAt) { + fields = append(fields, sev.FieldUpdatedAt) + } + if m.FieldCleared(sev.FieldCreatedAt) { + fields = append(fields, sev.FieldCreatedAt) + } + return fields +} + +// FieldCleared returns a boolean indicating if a field with the given name was +// cleared in this mutation. +func (m *SevMutation) 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 *SevMutation) ClearField(name string) error { + switch name { + case sev.FieldToken: + m.ClearToken() + return nil + case sev.FieldLimit: + m.ClearLimit() + return nil + case sev.FieldCount: + m.ClearCount() + return nil + case sev.FieldHandle: + m.ClearHandle() + return nil + case sev.FieldDid: + m.ClearDid() + return nil + case sev.FieldUID: + m.ClearUID() + return nil + case sev.FieldCid: + m.ClearCid() + return nil + case sev.FieldCp: + m.ClearCp() + return nil + case sev.FieldCard: + m.ClearCard() + return nil + case sev.FieldUpdatedAt: + m.ClearUpdatedAt() + return nil + case sev.FieldCreatedAt: + m.ClearCreatedAt() + return nil + } + return fmt.Errorf("unknown Sev 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 *SevMutation) ResetField(name string) error { + switch name { + case sev.FieldPassword: + m.ResetPassword() + return nil + case sev.FieldToken: + m.ResetToken() + return nil + case sev.FieldLimit: + m.ResetLimit() + return nil + case sev.FieldCount: + m.ResetCount() + return nil + case sev.FieldHandle: + m.ResetHandle() + return nil + case sev.FieldDid: + m.ResetDid() + return nil + case sev.FieldUID: + m.ResetUID() + return nil + case sev.FieldCid: + m.ResetCid() + return nil + case sev.FieldCp: + m.ResetCp() + return nil + case sev.FieldCard: + m.ResetCard() + return nil + case sev.FieldUpdatedAt: + m.ResetUpdatedAt() + return nil + case sev.FieldCreatedAt: + m.ResetCreatedAt() + return nil + } + return fmt.Errorf("unknown Sev field %s", name) +} + +// AddedEdges returns all edge names that were set/added in this mutation. +func (m *SevMutation) AddedEdges() []string { + edges := make([]string, 0, 1) + if m.owner != nil { + edges = append(edges, sev.EdgeOwner) + } + return edges +} + +// AddedIDs returns all IDs (to other nodes) that were added for the given edge +// name in this mutation. +func (m *SevMutation) AddedIDs(name string) []ent.Value { + switch name { + case sev.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 *SevMutation) 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 *SevMutation) RemovedIDs(name string) []ent.Value { + return nil +} + +// ClearedEdges returns all edge names that were cleared in this mutation. +func (m *SevMutation) ClearedEdges() []string { + edges := make([]string, 0, 1) + if m.clearedowner { + edges = append(edges, sev.EdgeOwner) + } + return edges +} + +// EdgeCleared returns a boolean which indicates if the edge with the given name +// was cleared in this mutation. +func (m *SevMutation) EdgeCleared(name string) bool { + switch name { + case sev.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 *SevMutation) ClearEdge(name string) error { + switch name { + case sev.EdgeOwner: + m.ClearOwner() + return nil + } + return fmt.Errorf("unknown Sev 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 *SevMutation) ResetEdge(name string) error { + switch name { + case sev.EdgeOwner: + m.ResetOwner() + return nil + } + return fmt.Errorf("unknown Sev edge %s", name) +} + // UeMutation represents an operation that mutates the Ue nodes in the graph. type UeMutation struct { config @@ -5217,6 +6591,9 @@ type UserMutation struct { ma map[int]struct{} removedma map[int]struct{} clearedma bool + sev map[int]struct{} + removedsev map[int]struct{} + clearedsev bool done bool oldValue func(context.Context) (*User, error) predicates []predicate.User @@ -8242,6 +9619,60 @@ func (m *UserMutation) ResetMa() { m.removedma = nil } +// AddSevIDs adds the "sev" edge to the Sev entity by ids. +func (m *UserMutation) AddSevIDs(ids ...int) { + if m.sev == nil { + m.sev = make(map[int]struct{}) + } + for i := range ids { + m.sev[ids[i]] = struct{}{} + } +} + +// ClearSev clears the "sev" edge to the Sev entity. +func (m *UserMutation) ClearSev() { + m.clearedsev = true +} + +// SevCleared reports if the "sev" edge to the Sev entity was cleared. +func (m *UserMutation) SevCleared() bool { + return m.clearedsev +} + +// RemoveSevIDs removes the "sev" edge to the Sev entity by IDs. +func (m *UserMutation) RemoveSevIDs(ids ...int) { + if m.removedsev == nil { + m.removedsev = make(map[int]struct{}) + } + for i := range ids { + delete(m.sev, ids[i]) + m.removedsev[ids[i]] = struct{}{} + } +} + +// RemovedSev returns the removed IDs of the "sev" edge to the Sev entity. +func (m *UserMutation) RemovedSevIDs() (ids []int) { + for id := range m.removedsev { + ids = append(ids, id) + } + return +} + +// SevIDs returns the "sev" edge IDs in the mutation. +func (m *UserMutation) SevIDs() (ids []int) { + for id := range m.sev { + ids = append(ids, id) + } + return +} + +// ResetSev resets all changes to the "sev" edge. +func (m *UserMutation) ResetSev() { + m.sev = nil + m.clearedsev = false + m.removedsev = nil +} + // Where appends a list predicates to the UserMutation builder. func (m *UserMutation) Where(ps ...predicate.User) { m.predicates = append(m.predicates, ps...) @@ -9694,7 +11125,7 @@ func (m *UserMutation) ResetField(name string) error { // AddedEdges returns all edge names that were set/added in this mutation. func (m *UserMutation) AddedEdges() []string { - edges := make([]string, 0, 3) + edges := make([]string, 0, 4) if m.card != nil { edges = append(edges, user.EdgeCard) } @@ -9704,6 +11135,9 @@ func (m *UserMutation) AddedEdges() []string { if m.ma != nil { edges = append(edges, user.EdgeMa) } + if m.sev != nil { + edges = append(edges, user.EdgeSev) + } return edges } @@ -9729,13 +11163,19 @@ func (m *UserMutation) AddedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case user.EdgeSev: + ids := make([]ent.Value, 0, len(m.sev)) + for id := range m.sev { + 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) + edges := make([]string, 0, 4) if m.removedcard != nil { edges = append(edges, user.EdgeCard) } @@ -9745,6 +11185,9 @@ func (m *UserMutation) RemovedEdges() []string { if m.removedma != nil { edges = append(edges, user.EdgeMa) } + if m.removedsev != nil { + edges = append(edges, user.EdgeSev) + } return edges } @@ -9770,13 +11213,19 @@ func (m *UserMutation) RemovedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case user.EdgeSev: + ids := make([]ent.Value, 0, len(m.removedsev)) + for id := range m.removedsev { + 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) + edges := make([]string, 0, 4) if m.clearedcard { edges = append(edges, user.EdgeCard) } @@ -9786,6 +11235,9 @@ func (m *UserMutation) ClearedEdges() []string { if m.clearedma { edges = append(edges, user.EdgeMa) } + if m.clearedsev { + edges = append(edges, user.EdgeSev) + } return edges } @@ -9799,6 +11251,8 @@ func (m *UserMutation) EdgeCleared(name string) bool { return m.clearedue case user.EdgeMa: return m.clearedma + case user.EdgeSev: + return m.clearedsev } return false } @@ -9824,6 +11278,9 @@ func (m *UserMutation) ResetEdge(name string) error { case user.EdgeMa: m.ResetMa() return nil + case user.EdgeSev: + m.ResetSev() + return nil } return fmt.Errorf("unknown User edge %s", name) } diff --git a/ent/ogent/oas_client_gen.go b/ent/ogent/oas_client_gen.go index 965601f..b9174c1 100644 --- a/ent/ogent/oas_client_gen.go +++ b/ent/ogent/oas_client_gen.go @@ -272,6 +272,77 @@ func (c *Client) sendCreateMa(ctx context.Context, request *CreateMaReq) (res Cr return result, nil } +// CreateSev invokes createSev operation. +// +// Creates a new Sev and persists it to storage. +// +// POST /sevs +func (c *Client) CreateSev(ctx context.Context, request *CreateSevReq) (CreateSevRes, error) { + res, err := c.sendCreateSev(ctx, request) + _ = res + return res, err +} + +func (c *Client) sendCreateSev(ctx context.Context, request *CreateSevReq) (res CreateSevRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("createSev"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "CreateSev", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/sevs" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeCreateSevRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeCreateSevResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // CreateUe invokes createUe operation. // // Creates a new Ue and persists it to storage. @@ -660,6 +731,88 @@ func (c *Client) sendDeleteMa(ctx context.Context, params DeleteMaParams) (res D return result, nil } +// DeleteSev invokes deleteSev operation. +// +// Deletes the Sev with the requested ID. +// +// DELETE /sevs/{id} +func (c *Client) DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error) { + res, err := c.sendDeleteSev(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendDeleteSev(ctx context.Context, params DeleteSevParams) (res DeleteSevRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deleteSev"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "DeleteSev", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/sevs/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "DELETE", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeDeleteSevResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // DeleteUe invokes deleteUe operation. // // Deletes the Ue with the requested ID. @@ -1429,6 +1582,112 @@ func (c *Client) sendListMa(ctx context.Context, params ListMaParams) (res ListM return result, nil } +// ListSev invokes listSev operation. +// +// List Sevs. +// +// GET /sevs +func (c *Client) ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error) { + res, err := c.sendListSev(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendListSev(ctx context.Context, params ListSevParams) (res ListSevRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listSev"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "ListSev", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/sevs" + + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "page" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "page", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Page.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "itemsPerPage" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "itemsPerPage", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.ItemsPerPage.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeListSevResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // ListUe invokes listUe operation. // // List Ues. @@ -1883,6 +2142,127 @@ func (c *Client) sendListUserMa(ctx context.Context, params ListUserMaParams) (r return result, nil } +// ListUserSev invokes listUserSev operation. +// +// List attached Sevs. +// +// GET /users/{id}/sev +func (c *Client) ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error) { + res, err := c.sendListUserSev(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendListUserSev(ctx context.Context, params ListUserSevParams) (res ListUserSevRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listUserSev"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "ListUserSev", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/users/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + u.Path += "/sev" + + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "page" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "page", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Page.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "itemsPerPage" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "itemsPerPage", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.ItemsPerPage.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeListUserSevResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // ListUserUe invokes listUserUe operation. // // List attached Ues. @@ -2416,6 +2796,171 @@ func (c *Client) sendReadMaOwner(ctx context.Context, params ReadMaOwnerParams) return result, nil } +// ReadSev invokes readSev operation. +// +// Finds the Sev with the requested ID and returns it. +// +// GET /sevs/{id} +func (c *Client) ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error) { + res, err := c.sendReadSev(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendReadSev(ctx context.Context, params ReadSevParams) (res ReadSevRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readSev"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "ReadSev", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/sevs/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeReadSevResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ReadSevOwner invokes readSevOwner operation. +// +// Find the attached User of the Sev with the given ID. +// +// GET /sevs/{id}/owner +func (c *Client) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error) { + res, err := c.sendReadSevOwner(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (res ReadSevOwnerRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readSevOwner"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "ReadSevOwner", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/sevs/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + u.Path += "/owner" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeReadSevOwnerResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // ReadUe invokes readUe operation. // // Finds the Ue with the requested ID and returns it. @@ -2918,6 +3463,91 @@ func (c *Client) sendUpdateMa(ctx context.Context, request *UpdateMaReq, params return result, nil } +// UpdateSev invokes updateSev operation. +// +// Updates a Sev and persists changes to storage. +// +// PATCH /sevs/{id} +func (c *Client) UpdateSev(ctx context.Context, request *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error) { + res, err := c.sendUpdateSev(ctx, request, params) + _ = res + return res, err +} + +func (c *Client) sendUpdateSev(ctx context.Context, request *UpdateSevReq, params UpdateSevParams) (res UpdateSevRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("updateSev"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "UpdateSev", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/sevs/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "PATCH", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeUpdateSevRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeUpdateSevResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // UpdateUe invokes updateUe operation. // // Updates a Ue and persists changes to storage. diff --git a/ent/ogent/oas_handlers_gen.go b/ent/ogent/oas_handlers_gen.go index 76490a8..6192b6f 100644 --- a/ent/ogent/oas_handlers_gen.go +++ b/ent/ogent/oas_handlers_gen.go @@ -323,6 +323,108 @@ func (s *Server) handleCreateMaRequest(args [0]string, w http.ResponseWriter, r } } +// handleCreateSevRequest handles createSev operation. +// +// Creates a new Sev and persists it to storage. +// +// POST /sevs +func (s *Server) handleCreateSevRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("createSev"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/sevs"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateSev", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "CreateSev", + ID: "createSev", + } + ) + request, close, err := s.decodeCreateSevRequest(r) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response CreateSevRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "CreateSev", + OperationID: "createSev", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = *CreateSevReq + Params = struct{} + Response = CreateSevRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.CreateSev(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.CreateSev(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeCreateSevResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + // handleCreateUeRequest handles createUe operation. // // Creates a new Ue and persists it to storage. @@ -833,6 +935,108 @@ func (s *Server) handleDeleteMaRequest(args [1]string, w http.ResponseWriter, r } } +// handleDeleteSevRequest handles deleteSev operation. +// +// Deletes the Sev with the requested ID. +// +// DELETE /sevs/{id} +func (s *Server) handleDeleteSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deleteSev"), + semconv.HTTPMethodKey.String("DELETE"), + semconv.HTTPRouteKey.String("/sevs/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "DeleteSev", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "DeleteSev", + ID: "deleteSev", + } + ) + params, err := decodeDeleteSevParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response DeleteSevRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "DeleteSev", + OperationID: "deleteSev", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = DeleteSevParams + Response = DeleteSevRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackDeleteSevParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.DeleteSev(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.DeleteSev(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeDeleteSevResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + // handleDeleteUeRequest handles deleteUe operation. // // Deletes the Ue with the requested ID. @@ -1669,6 +1873,112 @@ func (s *Server) handleListMaRequest(args [0]string, w http.ResponseWriter, r *h } } +// handleListSevRequest handles listSev operation. +// +// List Sevs. +// +// GET /sevs +func (s *Server) handleListSevRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listSev"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/sevs"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ListSev", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "ListSev", + ID: "listSev", + } + ) + params, err := decodeListSevParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response ListSevRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ListSev", + OperationID: "listSev", + Body: nil, + Params: middleware.Parameters{ + { + Name: "page", + In: "query", + }: params.Page, + { + Name: "itemsPerPage", + In: "query", + }: params.ItemsPerPage, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ListSevParams + Response = ListSevRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackListSevParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ListSev(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ListSev(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeListSevResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + // handleListUeRequest handles listUe operation. // // List Ues. @@ -2101,6 +2411,116 @@ func (s *Server) handleListUserMaRequest(args [1]string, w http.ResponseWriter, } } +// handleListUserSevRequest handles listUserSev operation. +// +// List attached Sevs. +// +// GET /users/{id}/sev +func (s *Server) handleListUserSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listUserSev"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/users/{id}/sev"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ListUserSev", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "ListUserSev", + ID: "listUserSev", + } + ) + params, err := decodeListUserSevParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response ListUserSevRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ListUserSev", + OperationID: "listUserSev", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + { + Name: "page", + In: "query", + }: params.Page, + { + Name: "itemsPerPage", + In: "query", + }: params.ItemsPerPage, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ListUserSevParams + Response = ListUserSevRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackListUserSevParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ListUserSev(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ListUserSev(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeListUserSevResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + // handleListUserUeRequest handles listUserUe operation. // // List attached Ues. @@ -2721,6 +3141,210 @@ func (s *Server) handleReadMaOwnerRequest(args [1]string, w http.ResponseWriter, } } +// handleReadSevRequest handles readSev operation. +// +// Finds the Sev with the requested ID and returns it. +// +// GET /sevs/{id} +func (s *Server) handleReadSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readSev"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/sevs/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadSev", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "ReadSev", + ID: "readSev", + } + ) + params, err := decodeReadSevParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response ReadSevRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ReadSev", + OperationID: "readSev", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ReadSevParams + Response = ReadSevRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackReadSevParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ReadSev(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ReadSev(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeReadSevResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleReadSevOwnerRequest handles readSevOwner operation. +// +// Find the attached User of the Sev with the given ID. +// +// GET /sevs/{id}/owner +func (s *Server) handleReadSevOwnerRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readSevOwner"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/sevs/{id}/owner"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadSevOwner", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "ReadSevOwner", + ID: "readSevOwner", + } + ) + params, err := decodeReadSevOwnerParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response ReadSevOwnerRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ReadSevOwner", + OperationID: "readSevOwner", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ReadSevOwnerParams + Response = ReadSevOwnerRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackReadSevOwnerParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ReadSevOwner(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ReadSevOwner(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeReadSevOwnerResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + // handleReadUeRequest handles readUe operation. // // Finds the Ue with the requested ID and returns it. @@ -3378,6 +4002,123 @@ func (s *Server) handleUpdateMaRequest(args [1]string, w http.ResponseWriter, r } } +// handleUpdateSevRequest handles updateSev operation. +// +// Updates a Sev and persists changes to storage. +// +// PATCH /sevs/{id} +func (s *Server) handleUpdateSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("updateSev"), + semconv.HTTPMethodKey.String("PATCH"), + semconv.HTTPRouteKey.String("/sevs/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdateSev", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "UpdateSev", + ID: "updateSev", + } + ) + params, err := decodeUpdateSevParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + request, close, err := s.decodeUpdateSevRequest(r) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response UpdateSevRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "UpdateSev", + OperationID: "updateSev", + Body: request, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = *UpdateSevReq + Params = UpdateSevParams + Response = UpdateSevRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackUpdateSevParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.UpdateSev(ctx, request, params) + return response, err + }, + ) + } else { + response, err = s.h.UpdateSev(ctx, request, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeUpdateSevResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + // handleUpdateUeRequest handles updateUe operation. // // Updates a Ue and persists changes to storage. diff --git a/ent/ogent/oas_interfaces_gen.go b/ent/ogent/oas_interfaces_gen.go index b7b87b5..6147fb1 100644 --- a/ent/ogent/oas_interfaces_gen.go +++ b/ent/ogent/oas_interfaces_gen.go @@ -13,6 +13,10 @@ type CreateMaRes interface { createMaRes() } +type CreateSevRes interface { + createSevRes() +} + type CreateUeRes interface { createUeRes() } @@ -33,6 +37,10 @@ type DeleteMaRes interface { deleteMaRes() } +type DeleteSevRes interface { + deleteSevRes() +} + type DeleteUeRes interface { deleteUeRes() } @@ -57,6 +65,10 @@ type ListMaRes interface { listMaRes() } +type ListSevRes interface { + listSevRes() +} + type ListUeRes interface { listUeRes() } @@ -73,6 +85,10 @@ type ListUserRes interface { listUserRes() } +type ListUserSevRes interface { + listUserSevRes() +} + type ListUserUeRes interface { listUserUeRes() } @@ -97,6 +113,14 @@ type ReadMaRes interface { readMaRes() } +type ReadSevOwnerRes interface { + readSevOwnerRes() +} + +type ReadSevRes interface { + readSevRes() +} + type ReadUeOwnerRes interface { readUeOwnerRes() } @@ -121,6 +145,10 @@ type UpdateMaRes interface { updateMaRes() } +type UpdateSevRes interface { + updateSevRes() +} + type UpdateUeRes interface { updateUeRes() } diff --git a/ent/ogent/oas_json_gen.go b/ent/ogent/oas_json_gen.go index f8c97d9..d431ec6 100644 --- a/ent/ogent/oas_json_gen.go +++ b/ent/ogent/oas_json_gen.go @@ -2621,6 +2621,309 @@ func (s *CreateMaReq) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *CreateSevReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CreateSevReq) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("password") + e.Str(s.Password) + } + { + if s.Token.Set { + e.FieldStart("token") + s.Token.Encode(e) + } + } + { + if s.Limit.Set { + e.FieldStart("limit") + s.Limit.Encode(e) + } + } + { + if s.Count.Set { + e.FieldStart("count") + s.Count.Encode(e) + } + } + { + if s.Handle.Set { + e.FieldStart("handle") + s.Handle.Encode(e) + } + } + { + if s.Did.Set { + e.FieldStart("did") + s.Did.Encode(e) + } + } + { + if s.UID.Set { + e.FieldStart("uid") + s.UID.Encode(e) + } + } + { + if s.Cid.Set { + e.FieldStart("cid") + s.Cid.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } + { + + e.FieldStart("owner") + e.Int(s.Owner) + } +} + +var jsonFieldsNameOfCreateSevReq = [13]string{ + 0: "password", + 1: "token", + 2: "limit", + 3: "count", + 4: "handle", + 5: "did", + 6: "uid", + 7: "cid", + 8: "cp", + 9: "card", + 10: "updated_at", + 11: "created_at", + 12: "owner", +} + +// Decode decodes CreateSevReq from json. +func (s *CreateSevReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreateSevReq to nil") + } + var requiredBitSet [2]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "password": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Password = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"password\"") + } + case "token": + if err := func() error { + s.Token.Reset() + if err := s.Token.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"token\"") + } + case "limit": + if err := func() error { + s.Limit.Reset() + if err := s.Limit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "count": + if err := func() error { + s.Count.Reset() + if err := s.Count.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"count\"") + } + case "handle": + if err := func() error { + s.Handle.Reset() + if err := s.Handle.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"handle\"") + } + case "did": + if err := func() error { + s.Did.Reset() + if err := s.Did.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"did\"") + } + case "uid": + if err := func() error { + s.UID.Reset() + if err := s.UID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"uid\"") + } + case "cid": + if err := func() error { + s.Cid.Reset() + if err := s.Cid.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cid\"") + } + case "cp": + if err := func() error { + s.Cp.Reset() + if err := s.Cp.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cp\"") + } + case "card": + if err := func() error { + s.Card.Reset() + if err := s.Card.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"card\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "owner": + requiredBitSet[1] |= 1 << 4 + if err := func() error { + v, err := d.Int() + s.Owner = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"owner\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CreateSevReq") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00000001, + 0b00010000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfCreateSevReq) { + name = jsonFieldsNameOfCreateSevReq[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *CreateSevReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreateSevReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *CreateUeReq) Encode(e *jx.Encoder) { e.ObjStart() @@ -3381,9 +3684,19 @@ func (s *CreateUserReq) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.Sev != nil { + e.FieldStart("sev") + e.ArrStart() + for _, elem := range s.Sev { + e.Int(elem) + } + e.ArrEnd() + } + } } -var jsonFieldsNameOfCreateUserReq = [53]string{ +var jsonFieldsNameOfCreateUserReq = [54]string{ 0: "username", 1: "did", 2: "member", @@ -3437,6 +3750,7 @@ var jsonFieldsNameOfCreateUserReq = [53]string{ 50: "card", 51: "ue", 52: "ma", + 53: "sev", } // Decode decodes CreateUserReq from json. @@ -4009,6 +4323,25 @@ func (s *CreateUserReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"ma\"") } + case "sev": + if err := func() error { + s.Sev = make([]int, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem int + v, err := d.Int() + elem = int(v) + if err != nil { + return err + } + s.Sev = append(s.Sev, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"sev\"") + } default: return d.Skip() } @@ -5651,6 +5984,56 @@ func (s *ListMaOKApplicationJSON) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes ListSevOKApplicationJSON as json. +func (s ListSevOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := []SevList(s) + + e.ArrStart() + for _, elem := range unwrapped { + elem.Encode(e) + } + e.ArrEnd() +} + +// Decode decodes ListSevOKApplicationJSON from json. +func (s *ListSevOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListSevOKApplicationJSON to nil") + } + var unwrapped []SevList + if err := func() error { + unwrapped = make([]SevList, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem SevList + if err := elem.Decode(d); err != nil { + return err + } + unwrapped = append(unwrapped, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = ListSevOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ListSevOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListSevOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes ListUeOKApplicationJSON as json. func (s ListUeOKApplicationJSON) Encode(e *jx.Encoder) { unwrapped := []UeList(s) @@ -5851,6 +6234,56 @@ func (s *ListUserOKApplicationJSON) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes ListUserSevOKApplicationJSON as json. +func (s ListUserSevOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := []UserSevList(s) + + e.ArrStart() + for _, elem := range unwrapped { + elem.Encode(e) + } + e.ArrEnd() +} + +// Decode decodes ListUserSevOKApplicationJSON from json. +func (s *ListUserSevOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListUserSevOKApplicationJSON to nil") + } + var unwrapped []UserSevList + if err := func() error { + unwrapped = make([]UserSevList, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem UserSevList + if err := elem.Decode(d); err != nil { + return err + } + unwrapped = append(unwrapped, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = ListUserSevOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ListUserSevOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListUserSevOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes ListUserUeOKApplicationJSON as json. func (s ListUserUeOKApplicationJSON) Encode(e *jx.Encoder) { unwrapped := []UserUeList(s) @@ -8705,6 +9138,1998 @@ func (s *R500) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *SevCreate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *SevCreate) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + if s.Limit.Set { + e.FieldStart("limit") + s.Limit.Encode(e) + } + } + { + if s.Count.Set { + e.FieldStart("count") + s.Count.Encode(e) + } + } + { + if s.Handle.Set { + e.FieldStart("handle") + s.Handle.Encode(e) + } + } + { + if s.Did.Set { + e.FieldStart("did") + s.Did.Encode(e) + } + } + { + if s.UID.Set { + e.FieldStart("uid") + s.UID.Encode(e) + } + } + { + if s.Cid.Set { + e.FieldStart("cid") + s.Cid.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } +} + +var jsonFieldsNameOfSevCreate = [11]string{ + 0: "id", + 1: "limit", + 2: "count", + 3: "handle", + 4: "did", + 5: "uid", + 6: "cid", + 7: "cp", + 8: "card", + 9: "updated_at", + 10: "created_at", +} + +// Decode decodes SevCreate from json. +func (s *SevCreate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode SevCreate to nil") + } + var requiredBitSet [2]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "limit": + if err := func() error { + s.Limit.Reset() + if err := s.Limit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "count": + if err := func() error { + s.Count.Reset() + if err := s.Count.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"count\"") + } + case "handle": + if err := func() error { + s.Handle.Reset() + if err := s.Handle.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"handle\"") + } + case "did": + if err := func() error { + s.Did.Reset() + if err := s.Did.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"did\"") + } + case "uid": + if err := func() error { + s.UID.Reset() + if err := s.UID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"uid\"") + } + case "cid": + if err := func() error { + s.Cid.Reset() + if err := s.Cid.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cid\"") + } + case "cp": + if err := func() error { + s.Cp.Reset() + if err := s.Cp.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cp\"") + } + case "card": + if err := func() error { + s.Card.Reset() + if err := s.Card.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"card\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode SevCreate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00000001, + 0b00000000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfSevCreate) { + name = jsonFieldsNameOfSevCreate[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *SevCreate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *SevCreate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *SevList) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *SevList) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + if s.Limit.Set { + e.FieldStart("limit") + s.Limit.Encode(e) + } + } + { + if s.Count.Set { + e.FieldStart("count") + s.Count.Encode(e) + } + } + { + if s.Handle.Set { + e.FieldStart("handle") + s.Handle.Encode(e) + } + } + { + if s.Did.Set { + e.FieldStart("did") + s.Did.Encode(e) + } + } + { + if s.UID.Set { + e.FieldStart("uid") + s.UID.Encode(e) + } + } + { + if s.Cid.Set { + e.FieldStart("cid") + s.Cid.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } +} + +var jsonFieldsNameOfSevList = [11]string{ + 0: "id", + 1: "limit", + 2: "count", + 3: "handle", + 4: "did", + 5: "uid", + 6: "cid", + 7: "cp", + 8: "card", + 9: "updated_at", + 10: "created_at", +} + +// Decode decodes SevList from json. +func (s *SevList) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode SevList to nil") + } + var requiredBitSet [2]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "limit": + if err := func() error { + s.Limit.Reset() + if err := s.Limit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "count": + if err := func() error { + s.Count.Reset() + if err := s.Count.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"count\"") + } + case "handle": + if err := func() error { + s.Handle.Reset() + if err := s.Handle.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"handle\"") + } + case "did": + if err := func() error { + s.Did.Reset() + if err := s.Did.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"did\"") + } + case "uid": + if err := func() error { + s.UID.Reset() + if err := s.UID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"uid\"") + } + case "cid": + if err := func() error { + s.Cid.Reset() + if err := s.Cid.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cid\"") + } + case "cp": + if err := func() error { + s.Cp.Reset() + if err := s.Cp.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cp\"") + } + case "card": + if err := func() error { + s.Card.Reset() + if err := s.Card.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"card\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode SevList") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00000001, + 0b00000000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfSevList) { + name = jsonFieldsNameOfSevList[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *SevList) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *SevList) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *SevOwnerRead) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *SevOwnerRead) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("username") + e.Str(s.Username) + } + { + if s.Did.Set { + e.FieldStart("did") + s.Did.Encode(e) + } + } + { + if s.Member.Set { + e.FieldStart("member") + s.Member.Encode(e) + } + } + { + if s.Book.Set { + e.FieldStart("book") + s.Book.Encode(e) + } + } + { + if s.Manga.Set { + e.FieldStart("manga") + s.Manga.Encode(e) + } + } + { + if s.Badge.Set { + e.FieldStart("badge") + s.Badge.Encode(e) + } + } + { + if s.Bsky.Set { + e.FieldStart("bsky") + s.Bsky.Encode(e) + } + } + { + if s.Mastodon.Set { + e.FieldStart("mastodon") + s.Mastodon.Encode(e) + } + } + { + if s.Delete.Set { + e.FieldStart("delete") + s.Delete.Encode(e) + } + } + { + if s.Handle.Set { + e.FieldStart("handle") + s.Handle.Encode(e) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.RaidAt.Set { + e.FieldStart("raid_at") + s.RaidAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.ServerAt.Set { + e.FieldStart("server_at") + s.ServerAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.EggAt.Set { + e.FieldStart("egg_at") + s.EggAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Luck.Set { + e.FieldStart("luck") + s.Luck.Encode(e) + } + } + { + if s.LuckAt.Set { + e.FieldStart("luck_at") + s.LuckAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Like.Set { + e.FieldStart("like") + s.Like.Encode(e) + } + } + { + if s.LikeRank.Set { + e.FieldStart("like_rank") + s.LikeRank.Encode(e) + } + } + { + if s.LikeAt.Set { + e.FieldStart("like_at") + s.LikeAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Fav.Set { + e.FieldStart("fav") + s.Fav.Encode(e) + } + } + { + if s.Ten.Set { + e.FieldStart("ten") + s.Ten.Encode(e) + } + } + { + if s.TenSu.Set { + e.FieldStart("ten_su") + s.TenSu.Encode(e) + } + } + { + if s.TenKai.Set { + e.FieldStart("ten_kai") + s.TenKai.Encode(e) + } + } + { + if s.Aiten.Set { + e.FieldStart("aiten") + s.Aiten.Encode(e) + } + } + { + if s.TenCard.Set { + e.FieldStart("ten_card") + s.TenCard.Encode(e) + } + } + { + if s.TenDelete.Set { + e.FieldStart("ten_delete") + s.TenDelete.Encode(e) + } + } + { + if s.TenPost.Set { + e.FieldStart("ten_post") + s.TenPost.Encode(e) + } + } + { + if s.TenGet.Set { + e.FieldStart("ten_get") + s.TenGet.Encode(e) + } + } + { + if s.TenAt.Set { + e.FieldStart("ten_at") + s.TenAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Next.Set { + e.FieldStart("next") + s.Next.Encode(e) + } + } + { + if s.Room.Set { + e.FieldStart("room") + s.Room.Encode(e) + } + } + { + if s.Model.Set { + e.FieldStart("model") + s.Model.Encode(e) + } + } + { + if s.ModelAt.Set { + e.FieldStart("model_at") + s.ModelAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.ModelAttack.Set { + e.FieldStart("model_attack") + s.ModelAttack.Encode(e) + } + } + { + if s.ModelLimit.Set { + e.FieldStart("model_limit") + s.ModelLimit.Encode(e) + } + } + { + if s.ModelSkill.Set { + e.FieldStart("model_skill") + s.ModelSkill.Encode(e) + } + } + { + if s.ModelMode.Set { + e.FieldStart("model_mode") + s.ModelMode.Encode(e) + } + } + { + if s.ModelCritical.Set { + e.FieldStart("model_critical") + s.ModelCritical.Encode(e) + } + } + { + if s.ModelCriticalD.Set { + e.FieldStart("model_critical_d") + s.ModelCriticalD.Encode(e) + } + } + { + if s.Game.Set { + e.FieldStart("game") + s.Game.Encode(e) + } + } + { + if s.GameTest.Set { + e.FieldStart("game_test") + s.GameTest.Encode(e) + } + } + { + if s.GameEnd.Set { + e.FieldStart("game_end") + s.GameEnd.Encode(e) + } + } + { + if s.GameAccount.Set { + e.FieldStart("game_account") + s.GameAccount.Encode(e) + } + } + { + if s.GameLv.Set { + e.FieldStart("game_lv") + s.GameLv.Encode(e) + } + } + { + if s.Coin.Set { + e.FieldStart("coin") + s.Coin.Encode(e) + } + } + { + if s.CoinOpen.Set { + e.FieldStart("coin_open") + s.CoinOpen.Encode(e) + } + } + { + if s.CoinAt.Set { + e.FieldStart("coin_at") + s.CoinAt.Encode(e, json.EncodeDateTime) + } + } +} + +var jsonFieldsNameOfSevOwnerRead = [49]string{ + 0: "id", + 1: "username", + 2: "did", + 3: "member", + 4: "book", + 5: "manga", + 6: "badge", + 7: "bsky", + 8: "mastodon", + 9: "delete", + 10: "handle", + 11: "created_at", + 12: "updated_at", + 13: "raid_at", + 14: "server_at", + 15: "egg_at", + 16: "luck", + 17: "luck_at", + 18: "like", + 19: "like_rank", + 20: "like_at", + 21: "fav", + 22: "ten", + 23: "ten_su", + 24: "ten_kai", + 25: "aiten", + 26: "ten_card", + 27: "ten_delete", + 28: "ten_post", + 29: "ten_get", + 30: "ten_at", + 31: "next", + 32: "room", + 33: "model", + 34: "model_at", + 35: "model_attack", + 36: "model_limit", + 37: "model_skill", + 38: "model_mode", + 39: "model_critical", + 40: "model_critical_d", + 41: "game", + 42: "game_test", + 43: "game_end", + 44: "game_account", + 45: "game_lv", + 46: "coin", + 47: "coin_open", + 48: "coin_at", +} + +// Decode decodes SevOwnerRead from json. +func (s *SevOwnerRead) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode SevOwnerRead to nil") + } + var requiredBitSet [7]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "username": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Username = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"username\"") + } + case "did": + if err := func() error { + s.Did.Reset() + if err := s.Did.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"did\"") + } + case "member": + if err := func() error { + s.Member.Reset() + if err := s.Member.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"member\"") + } + case "book": + if err := func() error { + s.Book.Reset() + if err := s.Book.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"book\"") + } + case "manga": + if err := func() error { + s.Manga.Reset() + if err := s.Manga.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"manga\"") + } + case "badge": + if err := func() error { + s.Badge.Reset() + if err := s.Badge.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"badge\"") + } + case "bsky": + if err := func() error { + s.Bsky.Reset() + if err := s.Bsky.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bsky\"") + } + case "mastodon": + if err := func() error { + s.Mastodon.Reset() + if err := s.Mastodon.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"mastodon\"") + } + case "delete": + if err := func() error { + s.Delete.Reset() + if err := s.Delete.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"delete\"") + } + case "handle": + if err := func() error { + s.Handle.Reset() + if err := s.Handle.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"handle\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + case "raid_at": + if err := func() error { + s.RaidAt.Reset() + if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raid_at\"") + } + case "server_at": + if err := func() error { + s.ServerAt.Reset() + if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"server_at\"") + } + case "egg_at": + if err := func() error { + s.EggAt.Reset() + if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"egg_at\"") + } + case "luck": + if err := func() error { + s.Luck.Reset() + if err := s.Luck.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck\"") + } + case "luck_at": + if err := func() error { + s.LuckAt.Reset() + if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck_at\"") + } + case "like": + if err := func() error { + s.Like.Reset() + if err := s.Like.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like\"") + } + case "like_rank": + if err := func() error { + s.LikeRank.Reset() + if err := s.LikeRank.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_rank\"") + } + case "like_at": + if err := func() error { + s.LikeAt.Reset() + if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_at\"") + } + case "fav": + if err := func() error { + s.Fav.Reset() + if err := s.Fav.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"fav\"") + } + case "ten": + if err := func() error { + s.Ten.Reset() + if err := s.Ten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten\"") + } + case "ten_su": + if err := func() error { + s.TenSu.Reset() + if err := s.TenSu.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_su\"") + } + case "ten_kai": + if err := func() error { + s.TenKai.Reset() + if err := s.TenKai.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_kai\"") + } + case "aiten": + if err := func() error { + s.Aiten.Reset() + if err := s.Aiten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"aiten\"") + } + case "ten_card": + if err := func() error { + s.TenCard.Reset() + if err := s.TenCard.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_card\"") + } + case "ten_delete": + if err := func() error { + s.TenDelete.Reset() + if err := s.TenDelete.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_delete\"") + } + case "ten_post": + if err := func() error { + s.TenPost.Reset() + if err := s.TenPost.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_post\"") + } + case "ten_get": + if err := func() error { + s.TenGet.Reset() + if err := s.TenGet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_get\"") + } + case "ten_at": + if err := func() error { + s.TenAt.Reset() + if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_at\"") + } + case "next": + if err := func() error { + s.Next.Reset() + if err := s.Next.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"next\"") + } + case "room": + if err := func() error { + s.Room.Reset() + if err := s.Room.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"room\"") + } + case "model": + if err := func() error { + s.Model.Reset() + if err := s.Model.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model\"") + } + case "model_at": + if err := func() error { + s.ModelAt.Reset() + if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_at\"") + } + case "model_attack": + if err := func() error { + s.ModelAttack.Reset() + if err := s.ModelAttack.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_attack\"") + } + case "model_limit": + if err := func() error { + s.ModelLimit.Reset() + if err := s.ModelLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_limit\"") + } + case "model_skill": + if err := func() error { + s.ModelSkill.Reset() + if err := s.ModelSkill.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_skill\"") + } + case "model_mode": + if err := func() error { + s.ModelMode.Reset() + if err := s.ModelMode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_mode\"") + } + case "model_critical": + if err := func() error { + s.ModelCritical.Reset() + if err := s.ModelCritical.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical\"") + } + case "model_critical_d": + if err := func() error { + s.ModelCriticalD.Reset() + if err := s.ModelCriticalD.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical_d\"") + } + case "game": + if err := func() error { + s.Game.Reset() + if err := s.Game.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game\"") + } + case "game_test": + if err := func() error { + s.GameTest.Reset() + if err := s.GameTest.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_test\"") + } + case "game_end": + if err := func() error { + s.GameEnd.Reset() + if err := s.GameEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_end\"") + } + case "game_account": + if err := func() error { + s.GameAccount.Reset() + if err := s.GameAccount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_account\"") + } + case "game_lv": + if err := func() error { + s.GameLv.Reset() + if err := s.GameLv.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_lv\"") + } + case "coin": + if err := func() error { + s.Coin.Reset() + if err := s.Coin.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"coin\"") + } + case "coin_open": + if err := func() error { + s.CoinOpen.Reset() + if err := s.CoinOpen.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"coin_open\"") + } + case "coin_at": + if err := func() error { + s.CoinAt.Reset() + if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"coin_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode SevOwnerRead") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [7]uint8{ + 0b00000011, + 0b00000000, + 0b00000000, + 0b00000000, + 0b00000000, + 0b00000000, + 0b00000000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfSevOwnerRead) { + name = jsonFieldsNameOfSevOwnerRead[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *SevOwnerRead) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *SevOwnerRead) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *SevRead) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *SevRead) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + if s.Limit.Set { + e.FieldStart("limit") + s.Limit.Encode(e) + } + } + { + if s.Count.Set { + e.FieldStart("count") + s.Count.Encode(e) + } + } + { + if s.Handle.Set { + e.FieldStart("handle") + s.Handle.Encode(e) + } + } + { + if s.Did.Set { + e.FieldStart("did") + s.Did.Encode(e) + } + } + { + if s.UID.Set { + e.FieldStart("uid") + s.UID.Encode(e) + } + } + { + if s.Cid.Set { + e.FieldStart("cid") + s.Cid.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } +} + +var jsonFieldsNameOfSevRead = [11]string{ + 0: "id", + 1: "limit", + 2: "count", + 3: "handle", + 4: "did", + 5: "uid", + 6: "cid", + 7: "cp", + 8: "card", + 9: "updated_at", + 10: "created_at", +} + +// Decode decodes SevRead from json. +func (s *SevRead) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode SevRead to nil") + } + var requiredBitSet [2]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "limit": + if err := func() error { + s.Limit.Reset() + if err := s.Limit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "count": + if err := func() error { + s.Count.Reset() + if err := s.Count.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"count\"") + } + case "handle": + if err := func() error { + s.Handle.Reset() + if err := s.Handle.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"handle\"") + } + case "did": + if err := func() error { + s.Did.Reset() + if err := s.Did.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"did\"") + } + case "uid": + if err := func() error { + s.UID.Reset() + if err := s.UID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"uid\"") + } + case "cid": + if err := func() error { + s.Cid.Reset() + if err := s.Cid.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cid\"") + } + case "cp": + if err := func() error { + s.Cp.Reset() + if err := s.Cp.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cp\"") + } + case "card": + if err := func() error { + s.Card.Reset() + if err := s.Card.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"card\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode SevRead") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00000001, + 0b00000000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfSevRead) { + name = jsonFieldsNameOfSevRead[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *SevRead) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *SevRead) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *SevUpdate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *SevUpdate) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + if s.Limit.Set { + e.FieldStart("limit") + s.Limit.Encode(e) + } + } + { + if s.Count.Set { + e.FieldStart("count") + s.Count.Encode(e) + } + } + { + if s.Handle.Set { + e.FieldStart("handle") + s.Handle.Encode(e) + } + } + { + if s.Did.Set { + e.FieldStart("did") + s.Did.Encode(e) + } + } + { + if s.UID.Set { + e.FieldStart("uid") + s.UID.Encode(e) + } + } + { + if s.Cid.Set { + e.FieldStart("cid") + s.Cid.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } +} + +var jsonFieldsNameOfSevUpdate = [11]string{ + 0: "id", + 1: "limit", + 2: "count", + 3: "handle", + 4: "did", + 5: "uid", + 6: "cid", + 7: "cp", + 8: "card", + 9: "updated_at", + 10: "created_at", +} + +// Decode decodes SevUpdate from json. +func (s *SevUpdate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode SevUpdate to nil") + } + var requiredBitSet [2]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "limit": + if err := func() error { + s.Limit.Reset() + if err := s.Limit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "count": + if err := func() error { + s.Count.Reset() + if err := s.Count.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"count\"") + } + case "handle": + if err := func() error { + s.Handle.Reset() + if err := s.Handle.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"handle\"") + } + case "did": + if err := func() error { + s.Did.Reset() + if err := s.Did.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"did\"") + } + case "uid": + if err := func() error { + s.UID.Reset() + if err := s.UID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"uid\"") + } + case "cid": + if err := func() error { + s.Cid.Reset() + if err := s.Cid.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cid\"") + } + case "cp": + if err := func() error { + s.Cp.Reset() + if err := s.Cp.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cp\"") + } + case "card": + if err := func() error { + s.Card.Reset() + if err := s.Card.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"card\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode SevUpdate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00000001, + 0b00000000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfSevUpdate) { + name = jsonFieldsNameOfSevUpdate[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *SevUpdate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *SevUpdate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *UeCreate) Encode(e *jx.Encoder) { e.ObjStart() @@ -11736,6 +14161,239 @@ func (s *UpdateMaReq) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *UpdateSevReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UpdateSevReq) encodeFields(e *jx.Encoder) { + { + if s.Token.Set { + e.FieldStart("token") + s.Token.Encode(e) + } + } + { + if s.Limit.Set { + e.FieldStart("limit") + s.Limit.Encode(e) + } + } + { + if s.Count.Set { + e.FieldStart("count") + s.Count.Encode(e) + } + } + { + if s.Handle.Set { + e.FieldStart("handle") + s.Handle.Encode(e) + } + } + { + if s.Did.Set { + e.FieldStart("did") + s.Did.Encode(e) + } + } + { + if s.UID.Set { + e.FieldStart("uid") + s.UID.Encode(e) + } + } + { + if s.Cid.Set { + e.FieldStart("cid") + s.Cid.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Owner.Set { + e.FieldStart("owner") + s.Owner.Encode(e) + } + } +} + +var jsonFieldsNameOfUpdateSevReq = [11]string{ + 0: "token", + 1: "limit", + 2: "count", + 3: "handle", + 4: "did", + 5: "uid", + 6: "cid", + 7: "cp", + 8: "card", + 9: "updated_at", + 10: "owner", +} + +// Decode decodes UpdateSevReq from json. +func (s *UpdateSevReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UpdateSevReq to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "token": + if err := func() error { + s.Token.Reset() + if err := s.Token.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"token\"") + } + case "limit": + if err := func() error { + s.Limit.Reset() + if err := s.Limit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "count": + if err := func() error { + s.Count.Reset() + if err := s.Count.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"count\"") + } + case "handle": + if err := func() error { + s.Handle.Reset() + if err := s.Handle.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"handle\"") + } + case "did": + if err := func() error { + s.Did.Reset() + if err := s.Did.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"did\"") + } + case "uid": + if err := func() error { + s.UID.Reset() + if err := s.UID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"uid\"") + } + case "cid": + if err := func() error { + s.Cid.Reset() + if err := s.Cid.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cid\"") + } + case "cp": + if err := func() error { + s.Cp.Reset() + if err := s.Cp.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cp\"") + } + case "card": + if err := func() error { + s.Card.Reset() + if err := s.Card.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"card\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + case "owner": + if err := func() error { + s.Owner.Reset() + if err := s.Owner.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"owner\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UpdateSevReq") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UpdateSevReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UpdateSevReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *UpdateUeReq) Encode(e *jx.Encoder) { e.ObjStart() @@ -12409,9 +15067,19 @@ func (s *UpdateUserReq) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.Sev != nil { + e.FieldStart("sev") + e.ArrStart() + for _, elem := range s.Sev { + e.Int(elem) + } + e.ArrEnd() + } + } } -var jsonFieldsNameOfUpdateUserReq = [50]string{ +var jsonFieldsNameOfUpdateUserReq = [51]string{ 0: "did", 1: "member", 2: "book", @@ -12462,6 +15130,7 @@ var jsonFieldsNameOfUpdateUserReq = [50]string{ 47: "card", 48: "ue", 49: "ma", + 50: "sev", } // Decode decodes UpdateUserReq from json. @@ -12999,6 +15668,25 @@ func (s *UpdateUserReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"ma\"") } + case "sev": + if err := func() error { + s.Sev = make([]int, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem int + v, err := d.Int() + elem = int(v) + if err != nil { + return err + } + s.Sev = append(s.Sev, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"sev\"") + } default: return d.Skip() } @@ -16319,6 +19007,274 @@ func (s *UserRead) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *UserSevList) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UserSevList) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + if s.Limit.Set { + e.FieldStart("limit") + s.Limit.Encode(e) + } + } + { + if s.Count.Set { + e.FieldStart("count") + s.Count.Encode(e) + } + } + { + if s.Handle.Set { + e.FieldStart("handle") + s.Handle.Encode(e) + } + } + { + if s.Did.Set { + e.FieldStart("did") + s.Did.Encode(e) + } + } + { + if s.UID.Set { + e.FieldStart("uid") + s.UID.Encode(e) + } + } + { + if s.Cid.Set { + e.FieldStart("cid") + s.Cid.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } +} + +var jsonFieldsNameOfUserSevList = [11]string{ + 0: "id", + 1: "limit", + 2: "count", + 3: "handle", + 4: "did", + 5: "uid", + 6: "cid", + 7: "cp", + 8: "card", + 9: "updated_at", + 10: "created_at", +} + +// Decode decodes UserSevList from json. +func (s *UserSevList) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UserSevList to nil") + } + var requiredBitSet [2]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "limit": + if err := func() error { + s.Limit.Reset() + if err := s.Limit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"limit\"") + } + case "count": + if err := func() error { + s.Count.Reset() + if err := s.Count.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"count\"") + } + case "handle": + if err := func() error { + s.Handle.Reset() + if err := s.Handle.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"handle\"") + } + case "did": + if err := func() error { + s.Did.Reset() + if err := s.Did.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"did\"") + } + case "uid": + if err := func() error { + s.UID.Reset() + if err := s.UID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"uid\"") + } + case "cid": + if err := func() error { + s.Cid.Reset() + if err := s.Cid.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cid\"") + } + case "cp": + if err := func() error { + s.Cp.Reset() + if err := s.Cp.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cp\"") + } + case "card": + if err := func() error { + s.Card.Reset() + if err := s.Card.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"card\"") + } + case "updated_at": + if err := func() error { + s.UpdatedAt.Reset() + if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"updated_at\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UserSevList") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00000001, + 0b00000000, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfUserSevList) { + name = jsonFieldsNameOfUserSevList[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UserSevList) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserSevList) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *UserUeList) Encode(e *jx.Encoder) { e.ObjStart() diff --git a/ent/ogent/oas_parameters_gen.go b/ent/ogent/oas_parameters_gen.go index 1b0ee32..867cf82 100644 --- a/ent/ogent/oas_parameters_gen.go +++ b/ent/ogent/oas_parameters_gen.go @@ -201,6 +201,68 @@ func decodeDeleteMaParams(args [1]string, r *http.Request) (params DeleteMaParam return params, nil } +// DeleteSevParams is parameters of deleteSev operation. +type DeleteSevParams struct { + // ID of the Sev. + ID int +} + +func unpackDeleteSevParams(packed middleware.Parameters) (params DeleteSevParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeDeleteSevParams(args [1]string, r *http.Request) (params DeleteSevParams, _ error) { + // Decode path: id. + if err := func() error { + param, err := url.PathUnescape(args[0]) + if err != nil { + return errors.Wrap(err, "unescape path") + } + if len(param) > 0 { + d := uri.NewPathDecoder(uri.PathDecoderConfig{ + Param: "id", + Value: param, + Style: uri.PathStyleSimple, + Explode: false, + }) + + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt(val) + if err != nil { + return err + } + + params.ID = c + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "id", + In: "path", + Err: err, + } + } + return params, nil +} + // DeleteUeParams is parameters of deleteUe operation. type DeleteUeParams struct { // ID of the Ue. @@ -1109,6 +1171,171 @@ func decodeListMaParams(args [0]string, r *http.Request) (params ListMaParams, _ return params, nil } +// ListSevParams is parameters of listSev operation. +type ListSevParams struct { + // What page to render. + Page OptInt + // Item count to render per page. + ItemsPerPage OptInt +} + +func unpackListSevParams(packed middleware.Parameters) (params ListSevParams) { + { + key := middleware.ParameterKey{ + Name: "page", + In: "query", + } + if v, ok := packed[key]; ok { + params.Page = v.(OptInt) + } + } + { + key := middleware.ParameterKey{ + Name: "itemsPerPage", + In: "query", + } + if v, ok := packed[key]; ok { + params.ItemsPerPage = v.(OptInt) + } + } + return params +} + +func decodeListSevParams(args [0]string, r *http.Request) (params ListSevParams, _ error) { + q := uri.NewQueryDecoder(r.URL.Query()) + // Decode query: page. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "page", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotPageVal int + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt(val) + if err != nil { + return err + } + + paramsDotPageVal = c + return nil + }(); err != nil { + return err + } + params.Page.SetTo(paramsDotPageVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if params.Page.Set { + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 1, + MaxSet: false, + Max: 0, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + }).Validate(int64(params.Page.Value)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "page", + In: "query", + Err: err, + } + } + // Decode query: itemsPerPage. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "itemsPerPage", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotItemsPerPageVal int + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt(val) + if err != nil { + return err + } + + paramsDotItemsPerPageVal = c + return nil + }(); err != nil { + return err + } + params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if params.ItemsPerPage.Set { + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 1, + MaxSet: true, + Max: 5000, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + }).Validate(int64(params.ItemsPerPage.Value)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "itemsPerPage", + In: "query", + Err: err, + } + } + return params, nil +} + // ListUeParams is parameters of listUe operation. type ListUeParams struct { // What page to render. @@ -1773,6 +2000,173 @@ func decodeListUserMaParams(args [1]string, r *http.Request) (params ListUserMaP return params, nil } +// ListUserSevParams is parameters of listUserSev operation. +type ListUserSevParams struct { + // ID of the User. + ID int + // What page to render. + Page OptInt + // Item count to render per page. + ItemsPerPage OptInt +} + +func unpackListUserSevParams(packed middleware.Parameters) (params ListUserSevParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + { + key := middleware.ParameterKey{ + Name: "page", + In: "query", + } + if v, ok := packed[key]; ok { + params.Page = v.(OptInt) + } + } + { + key := middleware.ParameterKey{ + Name: "itemsPerPage", + In: "query", + } + if v, ok := packed[key]; ok { + params.ItemsPerPage = v.(OptInt) + } + } + return params +} + +func decodeListUserSevParams(args [1]string, r *http.Request) (params ListUserSevParams, _ error) { + q := uri.NewQueryDecoder(r.URL.Query()) + // Decode path: id. + if err := func() error { + param, err := url.PathUnescape(args[0]) + if err != nil { + return errors.Wrap(err, "unescape path") + } + if len(param) > 0 { + d := uri.NewPathDecoder(uri.PathDecoderConfig{ + Param: "id", + Value: param, + Style: uri.PathStyleSimple, + Explode: false, + }) + + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt(val) + if err != nil { + return err + } + + params.ID = c + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "id", + In: "path", + Err: err, + } + } + // Decode query: page. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "page", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotPageVal int + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt(val) + if err != nil { + return err + } + + paramsDotPageVal = c + return nil + }(); err != nil { + return err + } + params.Page.SetTo(paramsDotPageVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "page", + In: "query", + Err: err, + } + } + // Decode query: itemsPerPage. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "itemsPerPage", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotItemsPerPageVal int + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt(val) + if err != nil { + return err + } + + paramsDotItemsPerPageVal = c + return nil + }(); err != nil { + return err + } + params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "itemsPerPage", + In: "query", + Err: err, + } + } + return params, nil +} + // ListUserUeParams is parameters of listUserUe operation. type ListUserUeParams struct { // ID of the User. @@ -2250,6 +2644,130 @@ func decodeReadMaOwnerParams(args [1]string, r *http.Request) (params ReadMaOwne return params, nil } +// ReadSevParams is parameters of readSev operation. +type ReadSevParams struct { + // ID of the Sev. + ID int +} + +func unpackReadSevParams(packed middleware.Parameters) (params ReadSevParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeReadSevParams(args [1]string, r *http.Request) (params ReadSevParams, _ error) { + // Decode path: id. + if err := func() error { + param, err := url.PathUnescape(args[0]) + if err != nil { + return errors.Wrap(err, "unescape path") + } + if len(param) > 0 { + d := uri.NewPathDecoder(uri.PathDecoderConfig{ + Param: "id", + Value: param, + Style: uri.PathStyleSimple, + Explode: false, + }) + + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt(val) + if err != nil { + return err + } + + params.ID = c + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "id", + In: "path", + Err: err, + } + } + return params, nil +} + +// ReadSevOwnerParams is parameters of readSevOwner operation. +type ReadSevOwnerParams struct { + // ID of the Sev. + ID int +} + +func unpackReadSevOwnerParams(packed middleware.Parameters) (params ReadSevOwnerParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeReadSevOwnerParams(args [1]string, r *http.Request) (params ReadSevOwnerParams, _ error) { + // Decode path: id. + if err := func() error { + param, err := url.PathUnescape(args[0]) + if err != nil { + return errors.Wrap(err, "unescape path") + } + if len(param) > 0 { + d := uri.NewPathDecoder(uri.PathDecoderConfig{ + Param: "id", + Value: param, + Style: uri.PathStyleSimple, + Explode: false, + }) + + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt(val) + if err != nil { + return err + } + + params.ID = c + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "id", + In: "path", + Err: err, + } + } + return params, nil +} + // ReadUeParams is parameters of readUe operation. type ReadUeParams struct { // ID of the Ue. @@ -2622,6 +3140,68 @@ func decodeUpdateMaParams(args [1]string, r *http.Request) (params UpdateMaParam return params, nil } +// UpdateSevParams is parameters of updateSev operation. +type UpdateSevParams struct { + // ID of the Sev. + ID int +} + +func unpackUpdateSevParams(packed middleware.Parameters) (params UpdateSevParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeUpdateSevParams(args [1]string, r *http.Request) (params UpdateSevParams, _ error) { + // Decode path: id. + if err := func() error { + param, err := url.PathUnescape(args[0]) + if err != nil { + return errors.Wrap(err, "unescape path") + } + if len(param) > 0 { + d := uri.NewPathDecoder(uri.PathDecoderConfig{ + Param: "id", + Value: param, + Style: uri.PathStyleSimple, + Explode: false, + }) + + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt(val) + if err != nil { + return err + } + + params.ID = c + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "id", + In: "path", + Err: err, + } + } + return params, nil +} + // UpdateUeParams is parameters of updateUe operation. type UpdateUeParams struct { // ID of the Ue. diff --git a/ent/ogent/oas_request_decoders_gen.go b/ent/ogent/oas_request_decoders_gen.go index 982725c..9b3e87e 100644 --- a/ent/ogent/oas_request_decoders_gen.go +++ b/ent/ogent/oas_request_decoders_gen.go @@ -204,6 +204,69 @@ func (s *Server) decodeCreateMaRequest(r *http.Request) ( } } +func (s *Server) decodeCreateSevRequest(r *http.Request) ( + req *CreateSevReq, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + + var request CreateSevReq + if err := func() error { + if err := request.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return &request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + func (s *Server) decodeCreateUeRequest(r *http.Request) ( req *CreateUeReq, close func() error, @@ -519,6 +582,69 @@ func (s *Server) decodeUpdateMaRequest(r *http.Request) ( } } +func (s *Server) decodeUpdateSevRequest(r *http.Request) ( + req *UpdateSevReq, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + + var request UpdateSevReq + if err := func() error { + if err := request.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return &request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + func (s *Server) decodeUpdateUeRequest(r *http.Request) ( req *UpdateUeReq, close func() error, diff --git a/ent/ogent/oas_request_encoders_gen.go b/ent/ogent/oas_request_encoders_gen.go index f0321d0..9bb492e 100644 --- a/ent/ogent/oas_request_encoders_gen.go +++ b/ent/ogent/oas_request_encoders_gen.go @@ -53,6 +53,20 @@ func encodeCreateMaRequest( return nil } +func encodeCreateSevRequest( + req *CreateSevReq, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + func encodeCreateUeRequest( req *CreateUeReq, r *http.Request, @@ -123,6 +137,20 @@ func encodeUpdateMaRequest( return nil } +func encodeUpdateSevRequest( + req *UpdateSevReq, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + func encodeUpdateUeRequest( req *UpdateUeReq, r *http.Request, diff --git a/ent/ogent/oas_response_decoders_gen.go b/ent/ogent/oas_response_decoders_gen.go index 8dd8a33..731a280 100644 --- a/ent/ogent/oas_response_decoders_gen.go +++ b/ent/ogent/oas_response_decoders_gen.go @@ -452,6 +452,152 @@ func decodeCreateMaResponse(resp *http.Response) (res CreateMaRes, err error) { return res, validate.UnexpectedStatusCode(resp.StatusCode) } +func decodeCreateSevResponse(resp *http.Response) (res CreateSevRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response SevCreate + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + func decodeCreateUeResponse(resp *http.Response) (res CreateUeRes, err error) { switch resp.StatusCode { case 200: @@ -1191,6 +1337,155 @@ func decodeDeleteMaResponse(resp *http.Response) (res DeleteMaRes, err error) { return res, validate.UnexpectedStatusCode(resp.StatusCode) } +func decodeDeleteSevResponse(resp *http.Response) (res DeleteSevRes, err error) { + switch resp.StatusCode { + case 204: + // Code 204. + return &DeleteSevNoContent{}, nil + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + func decodeDeleteUeResponse(resp *http.Response) (res DeleteUeRes, err error) { switch resp.StatusCode { case 204: @@ -2231,6 +2526,187 @@ func decodeListMaResponse(resp *http.Response) (res ListMaRes, err error) { return res, validate.UnexpectedStatusCode(resp.StatusCode) } +func decodeListSevResponse(resp *http.Response) (res ListSevRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ListSevOKApplicationJSON + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + func decodeListUeResponse(resp *http.Response) (res ListUeRes, err error) { switch resp.StatusCode { case 200: @@ -2955,6 +3431,187 @@ func decodeListUserMaResponse(resp *http.Response) (res ListUserMaRes, err error return res, validate.UnexpectedStatusCode(resp.StatusCode) } +func decodeListUserSevResponse(resp *http.Response) (res ListUserSevRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ListUserSevOKApplicationJSON + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + func decodeListUserUeResponse(resp *http.Response) (res ListUserUeRes, err error) { switch resp.StatusCode { case 200: @@ -4041,6 +4698,368 @@ func decodeReadMaOwnerResponse(resp *http.Response) (res ReadMaOwnerRes, err err return res, validate.UnexpectedStatusCode(resp.StatusCode) } +func decodeReadSevResponse(resp *http.Response) (res ReadSevRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response SevRead + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeReadSevOwnerResponse(resp *http.Response) (res ReadSevOwnerRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response SevOwnerRead + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + func decodeReadUeResponse(resp *http.Response) (res ReadUeRes, err error) { switch resp.StatusCode { case 200: @@ -5127,6 +6146,187 @@ func decodeUpdateMaResponse(resp *http.Response) (res UpdateMaRes, err error) { return res, validate.UnexpectedStatusCode(resp.StatusCode) } +func decodeUpdateSevResponse(resp *http.Response) (res UpdateSevRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response SevUpdate + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + func decodeUpdateUeResponse(resp *http.Response) (res UpdateUeRes, err error) { switch resp.StatusCode { case 200: diff --git a/ent/ogent/oas_response_encoders_gen.go b/ent/ogent/oas_response_encoders_gen.go index 8432973..5ce3edb 100644 --- a/ent/ogent/oas_response_encoders_gen.go +++ b/ent/ogent/oas_response_encoders_gen.go @@ -176,6 +176,61 @@ func encodeCreateMaResponse(response CreateMaRes, w http.ResponseWriter, span tr } } +func encodeCreateSevResponse(response CreateSevRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *SevCreate: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeCreateUeResponse(response CreateUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *UeCreate: @@ -469,6 +524,67 @@ func encodeDeleteMaResponse(response DeleteMaRes, w http.ResponseWriter, span tr } } +func encodeDeleteSevResponse(response DeleteSevRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *DeleteSevNoContent: + w.WriteHeader(204) + span.SetStatus(codes.Ok, http.StatusText(204)) + + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeDeleteUeResponse(response DeleteUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *DeleteUeNoContent: @@ -875,6 +991,74 @@ func encodeListMaResponse(response ListMaRes, w http.ResponseWriter, span trace. } } +func encodeListSevResponse(response ListSevRes, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai") + switch response := response.(type) { + case *ListSevOKApplicationJSON: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeListUeResponse(response ListUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *ListUeOKApplicationJSON: @@ -1146,6 +1330,73 @@ func encodeListUserMaResponse(response ListUserMaRes, w http.ResponseWriter, spa } } +func encodeListUserSevResponse(response ListUserSevRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *ListUserSevOKApplicationJSON: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeListUserUeResponse(response ListUserUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *ListUserUeOKApplicationJSON: @@ -1485,6 +1736,7 @@ func encodeReadMaResponse(response ReadMaRes, w http.ResponseWriter, span trace. } func encodeReadMaOwnerResponse(response ReadMaOwnerRes, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Access-Control-Allow-Origin", "https://manga.syui.ai") switch response := response.(type) { case *MaOwnerRead: w.Header().Set("Content-Type", "application/json") @@ -1551,6 +1803,142 @@ func encodeReadMaOwnerResponse(response ReadMaOwnerRes, w http.ResponseWriter, s } } +func encodeReadSevResponse(response ReadSevRes, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai") + switch response := response.(type) { + case *SevRead: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + +func encodeReadSevOwnerResponse(response ReadSevOwnerRes, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai") + switch response := response.(type) { + case *SevOwnerRead: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeReadUeResponse(response ReadUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *UeRead: @@ -1686,6 +2074,7 @@ func encodeReadUeOwnerResponse(response ReadUeOwnerRes, w http.ResponseWriter, s } func encodeReadUserResponse(response ReadUserRes, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai") switch response := response.(type) { case *UserRead: w.Header().Set("Content-Type", "application/json") @@ -1953,6 +2342,73 @@ func encodeUpdateMaResponse(response UpdateMaRes, w http.ResponseWriter, span tr } } +func encodeUpdateSevResponse(response UpdateSevRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *SevUpdate: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeUpdateUeResponse(response UpdateUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *UeUpdate: diff --git a/ent/ogent/oas_router_gen.go b/ent/ogent/oas_router_gen.go index 86dff67..8b90916 100644 --- a/ent/ogent/oas_router_gen.go +++ b/ent/ogent/oas_router_gen.go @@ -318,6 +318,85 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { s.notAllowed(w, r, "GET") } + return + } + } + } + case 's': // Prefix: "sevs" + if l := len("sevs"); len(elem) >= l && elem[0:l] == "sevs" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleListSevRequest([0]string{}, w, r) + case "POST": + s.handleCreateSevRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "GET,POST") + } + + return + } + switch elem[0] { + case '/': // Prefix: "/" + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } + + // Param: "id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch r.Method { + case "DELETE": + s.handleDeleteSevRequest([1]string{ + args[0], + }, w, r) + case "GET": + s.handleReadSevRequest([1]string{ + args[0], + }, w, r) + case "PATCH": + s.handleUpdateSevRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "DELETE,GET,PATCH") + } + + return + } + switch elem[0] { + case '/': // Prefix: "/owner" + if l := len("/owner"); len(elem) >= l && elem[0:l] == "/owner" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleReadSevOwnerRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "GET") + } + return } } @@ -539,6 +618,26 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { s.notAllowed(w, r, "GET") } + return + } + case 's': // Prefix: "sev" + if l := len("sev"); len(elem) >= l && elem[0:l] == "sev" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleListUserSevRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "GET") + } + return } case 'u': // Prefix: "ue" @@ -964,6 +1063,101 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } } + case 's': // Prefix: "sevs" + if l := len("sevs"); len(elem) >= l && elem[0:l] == "sevs" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "GET": + r.name = "ListSev" + r.operationID = "listSev" + r.pathPattern = "/sevs" + r.args = args + r.count = 0 + return r, true + case "POST": + r.name = "CreateSev" + r.operationID = "createSev" + r.pathPattern = "/sevs" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/" + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } + + // Param: "id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch method { + case "DELETE": + r.name = "DeleteSev" + r.operationID = "deleteSev" + r.pathPattern = "/sevs/{id}" + r.args = args + r.count = 1 + return r, true + case "GET": + r.name = "ReadSev" + r.operationID = "readSev" + r.pathPattern = "/sevs/{id}" + r.args = args + r.count = 1 + return r, true + case "PATCH": + r.name = "UpdateSev" + r.operationID = "updateSev" + r.pathPattern = "/sevs/{id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/owner" + if l := len("/owner"); len(elem) >= l && elem[0:l] == "/owner" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "GET": + // Leaf: ReadSevOwner + r.name = "ReadSevOwner" + r.operationID = "readSevOwner" + r.pathPattern = "/sevs/{id}/owner" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + } + } case 'u': // Prefix: "u" if l := len("u"); len(elem) >= l && elem[0:l] == "u" { elem = elem[l:] @@ -1217,6 +1411,27 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } + case 's': // Prefix: "sev" + if l := len("sev"); len(elem) >= l && elem[0:l] == "sev" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "GET": + // Leaf: ListUserSev + r.name = "ListUserSev" + r.operationID = "listUserSev" + r.pathPattern = "/users/{id}/sev" + r.args = args + r.count = 1 + return r, true + default: + return + } + } case 'u': // Prefix: "ue" if l := len("ue"); len(elem) >= l && elem[0:l] == "ue" { elem = elem[l:] diff --git a/ent/ogent/oas_schemas_gen.go b/ent/ogent/oas_schemas_gen.go index 48243c9..7903a78 100644 --- a/ent/ogent/oas_schemas_gen.go +++ b/ent/ogent/oas_schemas_gen.go @@ -1299,6 +1299,152 @@ func (s *CreateMaReq) SetOwner(val int) { s.Owner = val } +type CreateSevReq struct { + Password string `json:"password"` + Token OptString `json:"token"` + Limit OptBool `json:"limit"` + Count OptInt `json:"count"` + Handle OptString `json:"handle"` + Did OptString `json:"did"` + UID OptInt `json:"uid"` + Cid OptInt `json:"cid"` + Cp OptInt `json:"cp"` + Card OptInt `json:"card"` + UpdatedAt OptDateTime `json:"updated_at"` + CreatedAt OptDateTime `json:"created_at"` + Owner int `json:"owner"` +} + +// GetPassword returns the value of Password. +func (s *CreateSevReq) GetPassword() string { + return s.Password +} + +// GetToken returns the value of Token. +func (s *CreateSevReq) GetToken() OptString { + return s.Token +} + +// GetLimit returns the value of Limit. +func (s *CreateSevReq) GetLimit() OptBool { + return s.Limit +} + +// GetCount returns the value of Count. +func (s *CreateSevReq) GetCount() OptInt { + return s.Count +} + +// GetHandle returns the value of Handle. +func (s *CreateSevReq) GetHandle() OptString { + return s.Handle +} + +// GetDid returns the value of Did. +func (s *CreateSevReq) GetDid() OptString { + return s.Did +} + +// GetUID returns the value of UID. +func (s *CreateSevReq) GetUID() OptInt { + return s.UID +} + +// GetCid returns the value of Cid. +func (s *CreateSevReq) GetCid() OptInt { + return s.Cid +} + +// GetCp returns the value of Cp. +func (s *CreateSevReq) GetCp() OptInt { + return s.Cp +} + +// GetCard returns the value of Card. +func (s *CreateSevReq) GetCard() OptInt { + return s.Card +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *CreateSevReq) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *CreateSevReq) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetOwner returns the value of Owner. +func (s *CreateSevReq) GetOwner() int { + return s.Owner +} + +// SetPassword sets the value of Password. +func (s *CreateSevReq) SetPassword(val string) { + s.Password = val +} + +// SetToken sets the value of Token. +func (s *CreateSevReq) SetToken(val OptString) { + s.Token = val +} + +// SetLimit sets the value of Limit. +func (s *CreateSevReq) SetLimit(val OptBool) { + s.Limit = val +} + +// SetCount sets the value of Count. +func (s *CreateSevReq) SetCount(val OptInt) { + s.Count = val +} + +// SetHandle sets the value of Handle. +func (s *CreateSevReq) SetHandle(val OptString) { + s.Handle = val +} + +// SetDid sets the value of Did. +func (s *CreateSevReq) SetDid(val OptString) { + s.Did = val +} + +// SetUID sets the value of UID. +func (s *CreateSevReq) SetUID(val OptInt) { + s.UID = val +} + +// SetCid sets the value of Cid. +func (s *CreateSevReq) SetCid(val OptInt) { + s.Cid = val +} + +// SetCp sets the value of Cp. +func (s *CreateSevReq) SetCp(val OptInt) { + s.Cp = val +} + +// SetCard sets the value of Card. +func (s *CreateSevReq) SetCard(val OptInt) { + s.Card = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *CreateSevReq) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *CreateSevReq) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetOwner sets the value of Owner. +func (s *CreateSevReq) SetOwner(val int) { + s.Owner = val +} + type CreateUeReq struct { Limit OptBool `json:"limit"` LimitBoss OptBool `json:"limit_boss"` @@ -1576,6 +1722,7 @@ type CreateUserReq struct { Card []int `json:"card"` Ue []int `json:"ue"` Ma []int `json:"ma"` + Sev []int `json:"sev"` } // GetUsername returns the value of Username. @@ -1843,6 +1990,11 @@ func (s *CreateUserReq) GetMa() []int { return s.Ma } +// GetSev returns the value of Sev. +func (s *CreateUserReq) GetSev() []int { + return s.Sev +} + // SetUsername sets the value of Username. func (s *CreateUserReq) SetUsername(val string) { s.Username = val @@ -2108,6 +2260,11 @@ func (s *CreateUserReq) SetMa(val []int) { s.Ma = val } +// SetSev sets the value of Sev. +func (s *CreateUserReq) SetSev(val []int) { + s.Sev = val +} + // DeleteCardNoContent is response for DeleteCard operation. type DeleteCardNoContent struct{} @@ -2123,6 +2280,11 @@ type DeleteMaNoContent struct{} func (*DeleteMaNoContent) deleteMaRes() {} +// DeleteSevNoContent is response for DeleteSev operation. +type DeleteSevNoContent struct{} + +func (*DeleteSevNoContent) deleteSevRes() {} + // DeleteUeNoContent is response for DeleteUe operation. type DeleteUeNoContent struct{} @@ -2808,6 +2970,10 @@ type ListMaOKApplicationJSON []MaList func (*ListMaOKApplicationJSON) listMaRes() {} +type ListSevOKApplicationJSON []SevList + +func (*ListSevOKApplicationJSON) listSevRes() {} + type ListUeOKApplicationJSON []UeList func (*ListUeOKApplicationJSON) listUeRes() {} @@ -2824,6 +2990,10 @@ type ListUserOKApplicationJSON []UserList func (*ListUserOKApplicationJSON) listUserRes() {} +type ListUserSevOKApplicationJSON []UserSevList + +func (*ListUserSevOKApplicationJSON) listUserSevRes() {} + type ListUserUeOKApplicationJSON []UserUeList func (*ListUserUeOKApplicationJSON) listUserUeRes() {} @@ -4190,33 +4360,40 @@ func (s *R400) SetErrors(val jx.Raw) { func (*R400) createCardRes() {} func (*R400) createGroupRes() {} func (*R400) createMaRes() {} +func (*R400) createSevRes() {} func (*R400) createUeRes() {} func (*R400) createUserRes() {} func (*R400) deleteCardRes() {} func (*R400) deleteGroupRes() {} func (*R400) deleteMaRes() {} +func (*R400) deleteSevRes() {} func (*R400) deleteUeRes() {} func (*R400) deleteUserRes() {} func (*R400) listCardRes() {} func (*R400) listGroupRes() {} func (*R400) listGroupUsersRes() {} func (*R400) listMaRes() {} +func (*R400) listSevRes() {} func (*R400) listUeRes() {} func (*R400) listUserCardRes() {} func (*R400) listUserMaRes() {} func (*R400) listUserRes() {} +func (*R400) listUserSevRes() {} func (*R400) listUserUeRes() {} func (*R400) readCardOwnerRes() {} func (*R400) readCardRes() {} func (*R400) readGroupRes() {} func (*R400) readMaOwnerRes() {} func (*R400) readMaRes() {} +func (*R400) readSevOwnerRes() {} +func (*R400) readSevRes() {} func (*R400) readUeOwnerRes() {} func (*R400) readUeRes() {} func (*R400) readUserRes() {} func (*R400) updateCardRes() {} func (*R400) updateGroupRes() {} func (*R400) updateMaRes() {} +func (*R400) updateSevRes() {} func (*R400) updateUeRes() {} func (*R400) updateUserRes() {} @@ -4259,28 +4436,34 @@ func (s *R404) SetErrors(val jx.Raw) { func (*R404) deleteCardRes() {} func (*R404) deleteGroupRes() {} func (*R404) deleteMaRes() {} +func (*R404) deleteSevRes() {} func (*R404) deleteUeRes() {} func (*R404) deleteUserRes() {} func (*R404) listCardRes() {} func (*R404) listGroupRes() {} func (*R404) listGroupUsersRes() {} func (*R404) listMaRes() {} +func (*R404) listSevRes() {} func (*R404) listUeRes() {} func (*R404) listUserCardRes() {} func (*R404) listUserMaRes() {} func (*R404) listUserRes() {} +func (*R404) listUserSevRes() {} func (*R404) listUserUeRes() {} func (*R404) readCardOwnerRes() {} func (*R404) readCardRes() {} func (*R404) readGroupRes() {} func (*R404) readMaOwnerRes() {} func (*R404) readMaRes() {} +func (*R404) readSevOwnerRes() {} +func (*R404) readSevRes() {} func (*R404) readUeOwnerRes() {} func (*R404) readUeRes() {} func (*R404) readUserRes() {} func (*R404) updateCardRes() {} func (*R404) updateGroupRes() {} func (*R404) updateMaRes() {} +func (*R404) updateSevRes() {} func (*R404) updateUeRes() {} func (*R404) updateUserRes() {} @@ -4323,33 +4506,40 @@ func (s *R409) SetErrors(val jx.Raw) { func (*R409) createCardRes() {} func (*R409) createGroupRes() {} func (*R409) createMaRes() {} +func (*R409) createSevRes() {} func (*R409) createUeRes() {} func (*R409) createUserRes() {} func (*R409) deleteCardRes() {} func (*R409) deleteGroupRes() {} func (*R409) deleteMaRes() {} +func (*R409) deleteSevRes() {} func (*R409) deleteUeRes() {} func (*R409) deleteUserRes() {} func (*R409) listCardRes() {} func (*R409) listGroupRes() {} func (*R409) listGroupUsersRes() {} func (*R409) listMaRes() {} +func (*R409) listSevRes() {} func (*R409) listUeRes() {} func (*R409) listUserCardRes() {} func (*R409) listUserMaRes() {} func (*R409) listUserRes() {} +func (*R409) listUserSevRes() {} func (*R409) listUserUeRes() {} func (*R409) readCardOwnerRes() {} func (*R409) readCardRes() {} func (*R409) readGroupRes() {} func (*R409) readMaOwnerRes() {} func (*R409) readMaRes() {} +func (*R409) readSevOwnerRes() {} +func (*R409) readSevRes() {} func (*R409) readUeOwnerRes() {} func (*R409) readUeRes() {} func (*R409) readUserRes() {} func (*R409) updateCardRes() {} func (*R409) updateGroupRes() {} func (*R409) updateMaRes() {} +func (*R409) updateSevRes() {} func (*R409) updateUeRes() {} func (*R409) updateUserRes() {} @@ -4392,36 +4582,1094 @@ func (s *R500) SetErrors(val jx.Raw) { func (*R500) createCardRes() {} func (*R500) createGroupRes() {} func (*R500) createMaRes() {} +func (*R500) createSevRes() {} func (*R500) createUeRes() {} func (*R500) createUserRes() {} func (*R500) deleteCardRes() {} func (*R500) deleteGroupRes() {} func (*R500) deleteMaRes() {} +func (*R500) deleteSevRes() {} func (*R500) deleteUeRes() {} func (*R500) deleteUserRes() {} func (*R500) listCardRes() {} func (*R500) listGroupRes() {} func (*R500) listGroupUsersRes() {} func (*R500) listMaRes() {} +func (*R500) listSevRes() {} func (*R500) listUeRes() {} func (*R500) listUserCardRes() {} func (*R500) listUserMaRes() {} func (*R500) listUserRes() {} +func (*R500) listUserSevRes() {} func (*R500) listUserUeRes() {} func (*R500) readCardOwnerRes() {} func (*R500) readCardRes() {} func (*R500) readGroupRes() {} func (*R500) readMaOwnerRes() {} func (*R500) readMaRes() {} +func (*R500) readSevOwnerRes() {} +func (*R500) readSevRes() {} func (*R500) readUeOwnerRes() {} func (*R500) readUeRes() {} func (*R500) readUserRes() {} func (*R500) updateCardRes() {} func (*R500) updateGroupRes() {} func (*R500) updateMaRes() {} +func (*R500) updateSevRes() {} func (*R500) updateUeRes() {} func (*R500) updateUserRes() {} +// Ref: #/components/schemas/SevCreate +type SevCreate struct { + ID int `json:"id"` + Limit OptBool `json:"limit"` + Count OptInt `json:"count"` + Handle OptString `json:"handle"` + Did OptString `json:"did"` + UID OptInt `json:"uid"` + Cid OptInt `json:"cid"` + Cp OptInt `json:"cp"` + Card OptInt `json:"card"` + UpdatedAt OptDateTime `json:"updated_at"` + CreatedAt OptDateTime `json:"created_at"` +} + +// GetID returns the value of ID. +func (s *SevCreate) GetID() int { + return s.ID +} + +// GetLimit returns the value of Limit. +func (s *SevCreate) GetLimit() OptBool { + return s.Limit +} + +// GetCount returns the value of Count. +func (s *SevCreate) GetCount() OptInt { + return s.Count +} + +// GetHandle returns the value of Handle. +func (s *SevCreate) GetHandle() OptString { + return s.Handle +} + +// GetDid returns the value of Did. +func (s *SevCreate) GetDid() OptString { + return s.Did +} + +// GetUID returns the value of UID. +func (s *SevCreate) GetUID() OptInt { + return s.UID +} + +// GetCid returns the value of Cid. +func (s *SevCreate) GetCid() OptInt { + return s.Cid +} + +// GetCp returns the value of Cp. +func (s *SevCreate) GetCp() OptInt { + return s.Cp +} + +// GetCard returns the value of Card. +func (s *SevCreate) GetCard() OptInt { + return s.Card +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *SevCreate) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *SevCreate) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *SevCreate) SetID(val int) { + s.ID = val +} + +// SetLimit sets the value of Limit. +func (s *SevCreate) SetLimit(val OptBool) { + s.Limit = val +} + +// SetCount sets the value of Count. +func (s *SevCreate) SetCount(val OptInt) { + s.Count = val +} + +// SetHandle sets the value of Handle. +func (s *SevCreate) SetHandle(val OptString) { + s.Handle = val +} + +// SetDid sets the value of Did. +func (s *SevCreate) SetDid(val OptString) { + s.Did = val +} + +// SetUID sets the value of UID. +func (s *SevCreate) SetUID(val OptInt) { + s.UID = val +} + +// SetCid sets the value of Cid. +func (s *SevCreate) SetCid(val OptInt) { + s.Cid = val +} + +// SetCp sets the value of Cp. +func (s *SevCreate) SetCp(val OptInt) { + s.Cp = val +} + +// SetCard sets the value of Card. +func (s *SevCreate) SetCard(val OptInt) { + s.Card = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *SevCreate) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *SevCreate) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +func (*SevCreate) createSevRes() {} + +// Ref: #/components/schemas/SevList +type SevList struct { + ID int `json:"id"` + Limit OptBool `json:"limit"` + Count OptInt `json:"count"` + Handle OptString `json:"handle"` + Did OptString `json:"did"` + UID OptInt `json:"uid"` + Cid OptInt `json:"cid"` + Cp OptInt `json:"cp"` + Card OptInt `json:"card"` + UpdatedAt OptDateTime `json:"updated_at"` + CreatedAt OptDateTime `json:"created_at"` +} + +// GetID returns the value of ID. +func (s *SevList) GetID() int { + return s.ID +} + +// GetLimit returns the value of Limit. +func (s *SevList) GetLimit() OptBool { + return s.Limit +} + +// GetCount returns the value of Count. +func (s *SevList) GetCount() OptInt { + return s.Count +} + +// GetHandle returns the value of Handle. +func (s *SevList) GetHandle() OptString { + return s.Handle +} + +// GetDid returns the value of Did. +func (s *SevList) GetDid() OptString { + return s.Did +} + +// GetUID returns the value of UID. +func (s *SevList) GetUID() OptInt { + return s.UID +} + +// GetCid returns the value of Cid. +func (s *SevList) GetCid() OptInt { + return s.Cid +} + +// GetCp returns the value of Cp. +func (s *SevList) GetCp() OptInt { + return s.Cp +} + +// GetCard returns the value of Card. +func (s *SevList) GetCard() OptInt { + return s.Card +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *SevList) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *SevList) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *SevList) SetID(val int) { + s.ID = val +} + +// SetLimit sets the value of Limit. +func (s *SevList) SetLimit(val OptBool) { + s.Limit = val +} + +// SetCount sets the value of Count. +func (s *SevList) SetCount(val OptInt) { + s.Count = val +} + +// SetHandle sets the value of Handle. +func (s *SevList) SetHandle(val OptString) { + s.Handle = val +} + +// SetDid sets the value of Did. +func (s *SevList) SetDid(val OptString) { + s.Did = val +} + +// SetUID sets the value of UID. +func (s *SevList) SetUID(val OptInt) { + s.UID = val +} + +// SetCid sets the value of Cid. +func (s *SevList) SetCid(val OptInt) { + s.Cid = val +} + +// SetCp sets the value of Cp. +func (s *SevList) SetCp(val OptInt) { + s.Cp = val +} + +// SetCard sets the value of Card. +func (s *SevList) SetCard(val OptInt) { + s.Card = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *SevList) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *SevList) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// Ref: #/components/schemas/Sev_OwnerRead +type SevOwnerRead struct { + ID int `json:"id"` + Username string `json:"username"` + Did OptString `json:"did"` + Member OptBool `json:"member"` + Book OptBool `json:"book"` + Manga OptBool `json:"manga"` + Badge OptBool `json:"badge"` + Bsky OptBool `json:"bsky"` + Mastodon OptBool `json:"mastodon"` + Delete OptBool `json:"delete"` + Handle OptBool `json:"handle"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + ServerAt OptDateTime `json:"server_at"` + EggAt OptDateTime `json:"egg_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + Fav OptInt `json:"fav"` + Ten OptBool `json:"ten"` + TenSu OptInt `json:"ten_su"` + TenKai OptInt `json:"ten_kai"` + Aiten OptInt `json:"aiten"` + TenCard OptString `json:"ten_card"` + TenDelete OptString `json:"ten_delete"` + TenPost OptString `json:"ten_post"` + TenGet OptString `json:"ten_get"` + TenAt OptDateTime `json:"ten_at"` + Next OptString `json:"next"` + Room OptInt `json:"room"` + Model OptBool `json:"model"` + ModelAt OptDateTime `json:"model_at"` + ModelAttack OptInt `json:"model_attack"` + ModelLimit OptInt `json:"model_limit"` + ModelSkill OptInt `json:"model_skill"` + ModelMode OptInt `json:"model_mode"` + ModelCritical OptInt `json:"model_critical"` + ModelCriticalD OptInt `json:"model_critical_d"` + Game OptBool `json:"game"` + GameTest OptBool `json:"game_test"` + GameEnd OptBool `json:"game_end"` + GameAccount OptBool `json:"game_account"` + GameLv OptInt `json:"game_lv"` + Coin OptInt `json:"coin"` + CoinOpen OptBool `json:"coin_open"` + CoinAt OptDateTime `json:"coin_at"` +} + +// GetID returns the value of ID. +func (s *SevOwnerRead) GetID() int { + return s.ID +} + +// GetUsername returns the value of Username. +func (s *SevOwnerRead) GetUsername() string { + return s.Username +} + +// GetDid returns the value of Did. +func (s *SevOwnerRead) GetDid() OptString { + return s.Did +} + +// GetMember returns the value of Member. +func (s *SevOwnerRead) GetMember() OptBool { + return s.Member +} + +// GetBook returns the value of Book. +func (s *SevOwnerRead) GetBook() OptBool { + return s.Book +} + +// GetManga returns the value of Manga. +func (s *SevOwnerRead) GetManga() OptBool { + return s.Manga +} + +// GetBadge returns the value of Badge. +func (s *SevOwnerRead) GetBadge() OptBool { + return s.Badge +} + +// GetBsky returns the value of Bsky. +func (s *SevOwnerRead) GetBsky() OptBool { + return s.Bsky +} + +// GetMastodon returns the value of Mastodon. +func (s *SevOwnerRead) GetMastodon() OptBool { + return s.Mastodon +} + +// GetDelete returns the value of Delete. +func (s *SevOwnerRead) GetDelete() OptBool { + return s.Delete +} + +// GetHandle returns the value of Handle. +func (s *SevOwnerRead) GetHandle() OptBool { + return s.Handle +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *SevOwnerRead) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *SevOwnerRead) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetRaidAt returns the value of RaidAt. +func (s *SevOwnerRead) GetRaidAt() OptDateTime { + return s.RaidAt +} + +// GetServerAt returns the value of ServerAt. +func (s *SevOwnerRead) GetServerAt() OptDateTime { + return s.ServerAt +} + +// GetEggAt returns the value of EggAt. +func (s *SevOwnerRead) GetEggAt() OptDateTime { + return s.EggAt +} + +// GetLuck returns the value of Luck. +func (s *SevOwnerRead) GetLuck() OptInt { + return s.Luck +} + +// GetLuckAt returns the value of LuckAt. +func (s *SevOwnerRead) GetLuckAt() OptDateTime { + return s.LuckAt +} + +// GetLike returns the value of Like. +func (s *SevOwnerRead) GetLike() OptInt { + return s.Like +} + +// GetLikeRank returns the value of LikeRank. +func (s *SevOwnerRead) GetLikeRank() OptInt { + return s.LikeRank +} + +// GetLikeAt returns the value of LikeAt. +func (s *SevOwnerRead) GetLikeAt() OptDateTime { + return s.LikeAt +} + +// GetFav returns the value of Fav. +func (s *SevOwnerRead) GetFav() OptInt { + return s.Fav +} + +// GetTen returns the value of Ten. +func (s *SevOwnerRead) GetTen() OptBool { + return s.Ten +} + +// GetTenSu returns the value of TenSu. +func (s *SevOwnerRead) GetTenSu() OptInt { + return s.TenSu +} + +// GetTenKai returns the value of TenKai. +func (s *SevOwnerRead) GetTenKai() OptInt { + return s.TenKai +} + +// GetAiten returns the value of Aiten. +func (s *SevOwnerRead) GetAiten() OptInt { + return s.Aiten +} + +// GetTenCard returns the value of TenCard. +func (s *SevOwnerRead) GetTenCard() OptString { + return s.TenCard +} + +// GetTenDelete returns the value of TenDelete. +func (s *SevOwnerRead) GetTenDelete() OptString { + return s.TenDelete +} + +// GetTenPost returns the value of TenPost. +func (s *SevOwnerRead) GetTenPost() OptString { + return s.TenPost +} + +// GetTenGet returns the value of TenGet. +func (s *SevOwnerRead) GetTenGet() OptString { + return s.TenGet +} + +// GetTenAt returns the value of TenAt. +func (s *SevOwnerRead) GetTenAt() OptDateTime { + return s.TenAt +} + +// GetNext returns the value of Next. +func (s *SevOwnerRead) GetNext() OptString { + return s.Next +} + +// GetRoom returns the value of Room. +func (s *SevOwnerRead) GetRoom() OptInt { + return s.Room +} + +// GetModel returns the value of Model. +func (s *SevOwnerRead) GetModel() OptBool { + return s.Model +} + +// GetModelAt returns the value of ModelAt. +func (s *SevOwnerRead) GetModelAt() OptDateTime { + return s.ModelAt +} + +// GetModelAttack returns the value of ModelAttack. +func (s *SevOwnerRead) GetModelAttack() OptInt { + return s.ModelAttack +} + +// GetModelLimit returns the value of ModelLimit. +func (s *SevOwnerRead) GetModelLimit() OptInt { + return s.ModelLimit +} + +// GetModelSkill returns the value of ModelSkill. +func (s *SevOwnerRead) GetModelSkill() OptInt { + return s.ModelSkill +} + +// GetModelMode returns the value of ModelMode. +func (s *SevOwnerRead) GetModelMode() OptInt { + return s.ModelMode +} + +// GetModelCritical returns the value of ModelCritical. +func (s *SevOwnerRead) GetModelCritical() OptInt { + return s.ModelCritical +} + +// GetModelCriticalD returns the value of ModelCriticalD. +func (s *SevOwnerRead) GetModelCriticalD() OptInt { + return s.ModelCriticalD +} + +// GetGame returns the value of Game. +func (s *SevOwnerRead) GetGame() OptBool { + return s.Game +} + +// GetGameTest returns the value of GameTest. +func (s *SevOwnerRead) GetGameTest() OptBool { + return s.GameTest +} + +// GetGameEnd returns the value of GameEnd. +func (s *SevOwnerRead) GetGameEnd() OptBool { + return s.GameEnd +} + +// GetGameAccount returns the value of GameAccount. +func (s *SevOwnerRead) GetGameAccount() OptBool { + return s.GameAccount +} + +// GetGameLv returns the value of GameLv. +func (s *SevOwnerRead) GetGameLv() OptInt { + return s.GameLv +} + +// GetCoin returns the value of Coin. +func (s *SevOwnerRead) GetCoin() OptInt { + return s.Coin +} + +// GetCoinOpen returns the value of CoinOpen. +func (s *SevOwnerRead) GetCoinOpen() OptBool { + return s.CoinOpen +} + +// GetCoinAt returns the value of CoinAt. +func (s *SevOwnerRead) GetCoinAt() OptDateTime { + return s.CoinAt +} + +// SetID sets the value of ID. +func (s *SevOwnerRead) SetID(val int) { + s.ID = val +} + +// SetUsername sets the value of Username. +func (s *SevOwnerRead) SetUsername(val string) { + s.Username = val +} + +// SetDid sets the value of Did. +func (s *SevOwnerRead) SetDid(val OptString) { + s.Did = val +} + +// SetMember sets the value of Member. +func (s *SevOwnerRead) SetMember(val OptBool) { + s.Member = val +} + +// SetBook sets the value of Book. +func (s *SevOwnerRead) SetBook(val OptBool) { + s.Book = val +} + +// SetManga sets the value of Manga. +func (s *SevOwnerRead) SetManga(val OptBool) { + s.Manga = val +} + +// SetBadge sets the value of Badge. +func (s *SevOwnerRead) SetBadge(val OptBool) { + s.Badge = val +} + +// SetBsky sets the value of Bsky. +func (s *SevOwnerRead) SetBsky(val OptBool) { + s.Bsky = val +} + +// SetMastodon sets the value of Mastodon. +func (s *SevOwnerRead) SetMastodon(val OptBool) { + s.Mastodon = val +} + +// SetDelete sets the value of Delete. +func (s *SevOwnerRead) SetDelete(val OptBool) { + s.Delete = val +} + +// SetHandle sets the value of Handle. +func (s *SevOwnerRead) SetHandle(val OptBool) { + s.Handle = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *SevOwnerRead) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *SevOwnerRead) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetRaidAt sets the value of RaidAt. +func (s *SevOwnerRead) SetRaidAt(val OptDateTime) { + s.RaidAt = val +} + +// SetServerAt sets the value of ServerAt. +func (s *SevOwnerRead) SetServerAt(val OptDateTime) { + s.ServerAt = val +} + +// SetEggAt sets the value of EggAt. +func (s *SevOwnerRead) SetEggAt(val OptDateTime) { + s.EggAt = val +} + +// SetLuck sets the value of Luck. +func (s *SevOwnerRead) SetLuck(val OptInt) { + s.Luck = val +} + +// SetLuckAt sets the value of LuckAt. +func (s *SevOwnerRead) SetLuckAt(val OptDateTime) { + s.LuckAt = val +} + +// SetLike sets the value of Like. +func (s *SevOwnerRead) SetLike(val OptInt) { + s.Like = val +} + +// SetLikeRank sets the value of LikeRank. +func (s *SevOwnerRead) SetLikeRank(val OptInt) { + s.LikeRank = val +} + +// SetLikeAt sets the value of LikeAt. +func (s *SevOwnerRead) SetLikeAt(val OptDateTime) { + s.LikeAt = val +} + +// SetFav sets the value of Fav. +func (s *SevOwnerRead) SetFav(val OptInt) { + s.Fav = val +} + +// SetTen sets the value of Ten. +func (s *SevOwnerRead) SetTen(val OptBool) { + s.Ten = val +} + +// SetTenSu sets the value of TenSu. +func (s *SevOwnerRead) SetTenSu(val OptInt) { + s.TenSu = val +} + +// SetTenKai sets the value of TenKai. +func (s *SevOwnerRead) SetTenKai(val OptInt) { + s.TenKai = val +} + +// SetAiten sets the value of Aiten. +func (s *SevOwnerRead) SetAiten(val OptInt) { + s.Aiten = val +} + +// SetTenCard sets the value of TenCard. +func (s *SevOwnerRead) SetTenCard(val OptString) { + s.TenCard = val +} + +// SetTenDelete sets the value of TenDelete. +func (s *SevOwnerRead) SetTenDelete(val OptString) { + s.TenDelete = val +} + +// SetTenPost sets the value of TenPost. +func (s *SevOwnerRead) SetTenPost(val OptString) { + s.TenPost = val +} + +// SetTenGet sets the value of TenGet. +func (s *SevOwnerRead) SetTenGet(val OptString) { + s.TenGet = val +} + +// SetTenAt sets the value of TenAt. +func (s *SevOwnerRead) SetTenAt(val OptDateTime) { + s.TenAt = val +} + +// SetNext sets the value of Next. +func (s *SevOwnerRead) SetNext(val OptString) { + s.Next = val +} + +// SetRoom sets the value of Room. +func (s *SevOwnerRead) SetRoom(val OptInt) { + s.Room = val +} + +// SetModel sets the value of Model. +func (s *SevOwnerRead) SetModel(val OptBool) { + s.Model = val +} + +// SetModelAt sets the value of ModelAt. +func (s *SevOwnerRead) SetModelAt(val OptDateTime) { + s.ModelAt = val +} + +// SetModelAttack sets the value of ModelAttack. +func (s *SevOwnerRead) SetModelAttack(val OptInt) { + s.ModelAttack = val +} + +// SetModelLimit sets the value of ModelLimit. +func (s *SevOwnerRead) SetModelLimit(val OptInt) { + s.ModelLimit = val +} + +// SetModelSkill sets the value of ModelSkill. +func (s *SevOwnerRead) SetModelSkill(val OptInt) { + s.ModelSkill = val +} + +// SetModelMode sets the value of ModelMode. +func (s *SevOwnerRead) SetModelMode(val OptInt) { + s.ModelMode = val +} + +// SetModelCritical sets the value of ModelCritical. +func (s *SevOwnerRead) SetModelCritical(val OptInt) { + s.ModelCritical = val +} + +// SetModelCriticalD sets the value of ModelCriticalD. +func (s *SevOwnerRead) SetModelCriticalD(val OptInt) { + s.ModelCriticalD = val +} + +// SetGame sets the value of Game. +func (s *SevOwnerRead) SetGame(val OptBool) { + s.Game = val +} + +// SetGameTest sets the value of GameTest. +func (s *SevOwnerRead) SetGameTest(val OptBool) { + s.GameTest = val +} + +// SetGameEnd sets the value of GameEnd. +func (s *SevOwnerRead) SetGameEnd(val OptBool) { + s.GameEnd = val +} + +// SetGameAccount sets the value of GameAccount. +func (s *SevOwnerRead) SetGameAccount(val OptBool) { + s.GameAccount = val +} + +// SetGameLv sets the value of GameLv. +func (s *SevOwnerRead) SetGameLv(val OptInt) { + s.GameLv = val +} + +// SetCoin sets the value of Coin. +func (s *SevOwnerRead) SetCoin(val OptInt) { + s.Coin = val +} + +// SetCoinOpen sets the value of CoinOpen. +func (s *SevOwnerRead) SetCoinOpen(val OptBool) { + s.CoinOpen = val +} + +// SetCoinAt sets the value of CoinAt. +func (s *SevOwnerRead) SetCoinAt(val OptDateTime) { + s.CoinAt = val +} + +func (*SevOwnerRead) readSevOwnerRes() {} + +// Ref: #/components/schemas/SevRead +type SevRead struct { + ID int `json:"id"` + Limit OptBool `json:"limit"` + Count OptInt `json:"count"` + Handle OptString `json:"handle"` + Did OptString `json:"did"` + UID OptInt `json:"uid"` + Cid OptInt `json:"cid"` + Cp OptInt `json:"cp"` + Card OptInt `json:"card"` + UpdatedAt OptDateTime `json:"updated_at"` + CreatedAt OptDateTime `json:"created_at"` +} + +// GetID returns the value of ID. +func (s *SevRead) GetID() int { + return s.ID +} + +// GetLimit returns the value of Limit. +func (s *SevRead) GetLimit() OptBool { + return s.Limit +} + +// GetCount returns the value of Count. +func (s *SevRead) GetCount() OptInt { + return s.Count +} + +// GetHandle returns the value of Handle. +func (s *SevRead) GetHandle() OptString { + return s.Handle +} + +// GetDid returns the value of Did. +func (s *SevRead) GetDid() OptString { + return s.Did +} + +// GetUID returns the value of UID. +func (s *SevRead) GetUID() OptInt { + return s.UID +} + +// GetCid returns the value of Cid. +func (s *SevRead) GetCid() OptInt { + return s.Cid +} + +// GetCp returns the value of Cp. +func (s *SevRead) GetCp() OptInt { + return s.Cp +} + +// GetCard returns the value of Card. +func (s *SevRead) GetCard() OptInt { + return s.Card +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *SevRead) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *SevRead) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *SevRead) SetID(val int) { + s.ID = val +} + +// SetLimit sets the value of Limit. +func (s *SevRead) SetLimit(val OptBool) { + s.Limit = val +} + +// SetCount sets the value of Count. +func (s *SevRead) SetCount(val OptInt) { + s.Count = val +} + +// SetHandle sets the value of Handle. +func (s *SevRead) SetHandle(val OptString) { + s.Handle = val +} + +// SetDid sets the value of Did. +func (s *SevRead) SetDid(val OptString) { + s.Did = val +} + +// SetUID sets the value of UID. +func (s *SevRead) SetUID(val OptInt) { + s.UID = val +} + +// SetCid sets the value of Cid. +func (s *SevRead) SetCid(val OptInt) { + s.Cid = val +} + +// SetCp sets the value of Cp. +func (s *SevRead) SetCp(val OptInt) { + s.Cp = val +} + +// SetCard sets the value of Card. +func (s *SevRead) SetCard(val OptInt) { + s.Card = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *SevRead) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *SevRead) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +func (*SevRead) readSevRes() {} + +// Ref: #/components/schemas/SevUpdate +type SevUpdate struct { + ID int `json:"id"` + Limit OptBool `json:"limit"` + Count OptInt `json:"count"` + Handle OptString `json:"handle"` + Did OptString `json:"did"` + UID OptInt `json:"uid"` + Cid OptInt `json:"cid"` + Cp OptInt `json:"cp"` + Card OptInt `json:"card"` + UpdatedAt OptDateTime `json:"updated_at"` + CreatedAt OptDateTime `json:"created_at"` +} + +// GetID returns the value of ID. +func (s *SevUpdate) GetID() int { + return s.ID +} + +// GetLimit returns the value of Limit. +func (s *SevUpdate) GetLimit() OptBool { + return s.Limit +} + +// GetCount returns the value of Count. +func (s *SevUpdate) GetCount() OptInt { + return s.Count +} + +// GetHandle returns the value of Handle. +func (s *SevUpdate) GetHandle() OptString { + return s.Handle +} + +// GetDid returns the value of Did. +func (s *SevUpdate) GetDid() OptString { + return s.Did +} + +// GetUID returns the value of UID. +func (s *SevUpdate) GetUID() OptInt { + return s.UID +} + +// GetCid returns the value of Cid. +func (s *SevUpdate) GetCid() OptInt { + return s.Cid +} + +// GetCp returns the value of Cp. +func (s *SevUpdate) GetCp() OptInt { + return s.Cp +} + +// GetCard returns the value of Card. +func (s *SevUpdate) GetCard() OptInt { + return s.Card +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *SevUpdate) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *SevUpdate) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *SevUpdate) SetID(val int) { + s.ID = val +} + +// SetLimit sets the value of Limit. +func (s *SevUpdate) SetLimit(val OptBool) { + s.Limit = val +} + +// SetCount sets the value of Count. +func (s *SevUpdate) SetCount(val OptInt) { + s.Count = val +} + +// SetHandle sets the value of Handle. +func (s *SevUpdate) SetHandle(val OptString) { + s.Handle = val +} + +// SetDid sets the value of Did. +func (s *SevUpdate) SetDid(val OptString) { + s.Did = val +} + +// SetUID sets the value of UID. +func (s *SevUpdate) SetUID(val OptInt) { + s.UID = val +} + +// SetCid sets the value of Cid. +func (s *SevUpdate) SetCid(val OptInt) { + s.Cid = val +} + +// SetCp sets the value of Cp. +func (s *SevUpdate) SetCp(val OptInt) { + s.Cp = val +} + +// SetCard sets the value of Card. +func (s *SevUpdate) SetCard(val OptInt) { + s.Card = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *SevUpdate) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *SevUpdate) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +func (*SevUpdate) updateSevRes() {} + // Ref: #/components/schemas/UeCreate type UeCreate struct { ID int `json:"id"` @@ -6054,6 +7302,130 @@ func (s *UpdateMaReq) SetOwner(val OptInt) { s.Owner = val } +type UpdateSevReq struct { + Token OptString `json:"token"` + Limit OptBool `json:"limit"` + Count OptInt `json:"count"` + Handle OptString `json:"handle"` + Did OptString `json:"did"` + UID OptInt `json:"uid"` + Cid OptInt `json:"cid"` + Cp OptInt `json:"cp"` + Card OptInt `json:"card"` + UpdatedAt OptDateTime `json:"updated_at"` + Owner OptInt `json:"owner"` +} + +// GetToken returns the value of Token. +func (s *UpdateSevReq) GetToken() OptString { + return s.Token +} + +// GetLimit returns the value of Limit. +func (s *UpdateSevReq) GetLimit() OptBool { + return s.Limit +} + +// GetCount returns the value of Count. +func (s *UpdateSevReq) GetCount() OptInt { + return s.Count +} + +// GetHandle returns the value of Handle. +func (s *UpdateSevReq) GetHandle() OptString { + return s.Handle +} + +// GetDid returns the value of Did. +func (s *UpdateSevReq) GetDid() OptString { + return s.Did +} + +// GetUID returns the value of UID. +func (s *UpdateSevReq) GetUID() OptInt { + return s.UID +} + +// GetCid returns the value of Cid. +func (s *UpdateSevReq) GetCid() OptInt { + return s.Cid +} + +// GetCp returns the value of Cp. +func (s *UpdateSevReq) GetCp() OptInt { + return s.Cp +} + +// GetCard returns the value of Card. +func (s *UpdateSevReq) GetCard() OptInt { + return s.Card +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *UpdateSevReq) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetOwner returns the value of Owner. +func (s *UpdateSevReq) GetOwner() OptInt { + return s.Owner +} + +// SetToken sets the value of Token. +func (s *UpdateSevReq) SetToken(val OptString) { + s.Token = val +} + +// SetLimit sets the value of Limit. +func (s *UpdateSevReq) SetLimit(val OptBool) { + s.Limit = val +} + +// SetCount sets the value of Count. +func (s *UpdateSevReq) SetCount(val OptInt) { + s.Count = val +} + +// SetHandle sets the value of Handle. +func (s *UpdateSevReq) SetHandle(val OptString) { + s.Handle = val +} + +// SetDid sets the value of Did. +func (s *UpdateSevReq) SetDid(val OptString) { + s.Did = val +} + +// SetUID sets the value of UID. +func (s *UpdateSevReq) SetUID(val OptInt) { + s.UID = val +} + +// SetCid sets the value of Cid. +func (s *UpdateSevReq) SetCid(val OptInt) { + s.Cid = val +} + +// SetCp sets the value of Cp. +func (s *UpdateSevReq) SetCp(val OptInt) { + s.Cp = val +} + +// SetCard sets the value of Card. +func (s *UpdateSevReq) SetCard(val OptInt) { + s.Card = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *UpdateSevReq) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetOwner sets the value of Owner. +func (s *UpdateSevReq) SetOwner(val OptInt) { + s.Owner = val +} + type UpdateUeReq struct { Limit OptBool `json:"limit"` LimitBoss OptBool `json:"limit_boss"` @@ -6306,6 +7678,7 @@ type UpdateUserReq struct { Card []int `json:"card"` Ue []int `json:"ue"` Ma []int `json:"ma"` + Sev []int `json:"sev"` } // GetDid returns the value of Did. @@ -6558,6 +7931,11 @@ func (s *UpdateUserReq) GetMa() []int { return s.Ma } +// GetSev returns the value of Sev. +func (s *UpdateUserReq) GetSev() []int { + return s.Sev +} + // SetDid sets the value of Did. func (s *UpdateUserReq) SetDid(val OptString) { s.Did = val @@ -6808,6 +8186,11 @@ func (s *UpdateUserReq) SetMa(val []int) { s.Ma = val } +// SetSev sets the value of Sev. +func (s *UpdateUserReq) SetSev(val []int) { + s.Sev = val +} + // Ref: #/components/schemas/User_CardList type UserCardList struct { ID int `json:"id"` @@ -8691,6 +10074,131 @@ func (s *UserRead) SetCoinAt(val OptDateTime) { func (*UserRead) readUserRes() {} +// Ref: #/components/schemas/User_SevList +type UserSevList struct { + ID int `json:"id"` + Limit OptBool `json:"limit"` + Count OptInt `json:"count"` + Handle OptString `json:"handle"` + Did OptString `json:"did"` + UID OptInt `json:"uid"` + Cid OptInt `json:"cid"` + Cp OptInt `json:"cp"` + Card OptInt `json:"card"` + UpdatedAt OptDateTime `json:"updated_at"` + CreatedAt OptDateTime `json:"created_at"` +} + +// GetID returns the value of ID. +func (s *UserSevList) GetID() int { + return s.ID +} + +// GetLimit returns the value of Limit. +func (s *UserSevList) GetLimit() OptBool { + return s.Limit +} + +// GetCount returns the value of Count. +func (s *UserSevList) GetCount() OptInt { + return s.Count +} + +// GetHandle returns the value of Handle. +func (s *UserSevList) GetHandle() OptString { + return s.Handle +} + +// GetDid returns the value of Did. +func (s *UserSevList) GetDid() OptString { + return s.Did +} + +// GetUID returns the value of UID. +func (s *UserSevList) GetUID() OptInt { + return s.UID +} + +// GetCid returns the value of Cid. +func (s *UserSevList) GetCid() OptInt { + return s.Cid +} + +// GetCp returns the value of Cp. +func (s *UserSevList) GetCp() OptInt { + return s.Cp +} + +// GetCard returns the value of Card. +func (s *UserSevList) GetCard() OptInt { + return s.Card +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *UserSevList) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserSevList) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *UserSevList) SetID(val int) { + s.ID = val +} + +// SetLimit sets the value of Limit. +func (s *UserSevList) SetLimit(val OptBool) { + s.Limit = val +} + +// SetCount sets the value of Count. +func (s *UserSevList) SetCount(val OptInt) { + s.Count = val +} + +// SetHandle sets the value of Handle. +func (s *UserSevList) SetHandle(val OptString) { + s.Handle = val +} + +// SetDid sets the value of Did. +func (s *UserSevList) SetDid(val OptString) { + s.Did = val +} + +// SetUID sets the value of UID. +func (s *UserSevList) SetUID(val OptInt) { + s.UID = val +} + +// SetCid sets the value of Cid. +func (s *UserSevList) SetCid(val OptInt) { + s.Cid = val +} + +// SetCp sets the value of Cp. +func (s *UserSevList) SetCp(val OptInt) { + s.Cp = val +} + +// SetCard sets the value of Card. +func (s *UserSevList) SetCard(val OptInt) { + s.Card = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *UserSevList) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserSevList) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + // Ref: #/components/schemas/User_UeList type UserUeList struct { ID int `json:"id"` diff --git a/ent/ogent/oas_server_gen.go b/ent/ogent/oas_server_gen.go index d07cd1c..565ed35 100644 --- a/ent/ogent/oas_server_gen.go +++ b/ent/ogent/oas_server_gen.go @@ -26,6 +26,12 @@ type Handler interface { // // POST /mas CreateMa(ctx context.Context, req *CreateMaReq) (CreateMaRes, error) + // CreateSev implements createSev operation. + // + // Creates a new Sev and persists it to storage. + // + // POST /sevs + CreateSev(ctx context.Context, req *CreateSevReq) (CreateSevRes, error) // CreateUe implements createUe operation. // // Creates a new Ue and persists it to storage. @@ -56,6 +62,12 @@ type Handler interface { // // DELETE /mas/{id} DeleteMa(ctx context.Context, params DeleteMaParams) (DeleteMaRes, error) + // DeleteSev implements deleteSev operation. + // + // Deletes the Sev with the requested ID. + // + // DELETE /sevs/{id} + DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error) // DeleteUe implements deleteUe operation. // // Deletes the Ue with the requested ID. @@ -104,6 +116,12 @@ type Handler interface { // // GET /mas ListMa(ctx context.Context, params ListMaParams) (ListMaRes, error) + // ListSev implements listSev operation. + // + // List Sevs. + // + // GET /sevs + ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error) // ListUe implements listUe operation. // // List Ues. @@ -128,6 +146,12 @@ type Handler interface { // // GET /users/{id}/ma ListUserMa(ctx context.Context, params ListUserMaParams) (ListUserMaRes, error) + // ListUserSev implements listUserSev operation. + // + // List attached Sevs. + // + // GET /users/{id}/sev + ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error) // ListUserUe implements listUserUe operation. // // List attached Ues. @@ -164,6 +188,18 @@ type Handler interface { // // GET /mas/{id}/owner ReadMaOwner(ctx context.Context, params ReadMaOwnerParams) (ReadMaOwnerRes, error) + // ReadSev implements readSev operation. + // + // Finds the Sev with the requested ID and returns it. + // + // GET /sevs/{id} + ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error) + // ReadSevOwner implements readSevOwner operation. + // + // Find the attached User of the Sev with the given ID. + // + // GET /sevs/{id}/owner + ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error) // ReadUe implements readUe operation. // // Finds the Ue with the requested ID and returns it. @@ -200,6 +236,12 @@ type Handler interface { // // PATCH /mas/{id} UpdateMa(ctx context.Context, req *UpdateMaReq, params UpdateMaParams) (UpdateMaRes, error) + // UpdateSev implements updateSev operation. + // + // Updates a Sev and persists changes to storage. + // + // PATCH /sevs/{id} + UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error) // UpdateUe implements updateUe operation. // // Updates a Ue and persists changes to storage. diff --git a/ent/ogent/oas_unimplemented_gen.go b/ent/ogent/oas_unimplemented_gen.go index 944d471..511e284 100644 --- a/ent/ogent/oas_unimplemented_gen.go +++ b/ent/ogent/oas_unimplemented_gen.go @@ -40,6 +40,15 @@ func (UnimplementedHandler) CreateMa(ctx context.Context, req *CreateMaReq) (r C return r, ht.ErrNotImplemented } +// CreateSev implements createSev operation. +// +// Creates a new Sev and persists it to storage. +// +// POST /sevs +func (UnimplementedHandler) CreateSev(ctx context.Context, req *CreateSevReq) (r CreateSevRes, _ error) { + return r, ht.ErrNotImplemented +} + // CreateUe implements createUe operation. // // Creates a new Ue and persists it to storage. @@ -85,6 +94,15 @@ func (UnimplementedHandler) DeleteMa(ctx context.Context, params DeleteMaParams) return r, ht.ErrNotImplemented } +// DeleteSev implements deleteSev operation. +// +// Deletes the Sev with the requested ID. +// +// DELETE /sevs/{id} +func (UnimplementedHandler) DeleteSev(ctx context.Context, params DeleteSevParams) (r DeleteSevRes, _ error) { + return r, ht.ErrNotImplemented +} + // DeleteUe implements deleteUe operation. // // Deletes the Ue with the requested ID. @@ -157,6 +175,15 @@ func (UnimplementedHandler) ListMa(ctx context.Context, params ListMaParams) (r return r, ht.ErrNotImplemented } +// ListSev implements listSev operation. +// +// List Sevs. +// +// GET /sevs +func (UnimplementedHandler) ListSev(ctx context.Context, params ListSevParams) (r ListSevRes, _ error) { + return r, ht.ErrNotImplemented +} + // ListUe implements listUe operation. // // List Ues. @@ -193,6 +220,15 @@ func (UnimplementedHandler) ListUserMa(ctx context.Context, params ListUserMaPar return r, ht.ErrNotImplemented } +// ListUserSev implements listUserSev operation. +// +// List attached Sevs. +// +// GET /users/{id}/sev +func (UnimplementedHandler) ListUserSev(ctx context.Context, params ListUserSevParams) (r ListUserSevRes, _ error) { + return r, ht.ErrNotImplemented +} + // ListUserUe implements listUserUe operation. // // List attached Ues. @@ -247,6 +283,24 @@ func (UnimplementedHandler) ReadMaOwner(ctx context.Context, params ReadMaOwnerP return r, ht.ErrNotImplemented } +// ReadSev implements readSev operation. +// +// Finds the Sev with the requested ID and returns it. +// +// GET /sevs/{id} +func (UnimplementedHandler) ReadSev(ctx context.Context, params ReadSevParams) (r ReadSevRes, _ error) { + return r, ht.ErrNotImplemented +} + +// ReadSevOwner implements readSevOwner operation. +// +// Find the attached User of the Sev with the given ID. +// +// GET /sevs/{id}/owner +func (UnimplementedHandler) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (r ReadSevOwnerRes, _ error) { + return r, ht.ErrNotImplemented +} + // ReadUe implements readUe operation. // // Finds the Ue with the requested ID and returns it. @@ -301,6 +355,15 @@ func (UnimplementedHandler) UpdateMa(ctx context.Context, req *UpdateMaReq, para return r, ht.ErrNotImplemented } +// UpdateSev implements updateSev operation. +// +// Updates a Sev and persists changes to storage. +// +// PATCH /sevs/{id} +func (UnimplementedHandler) UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (r UpdateSevRes, _ error) { + return r, ht.ErrNotImplemented +} + // UpdateUe implements updateUe operation. // // Updates a Ue and persists changes to storage. diff --git a/ent/ogent/oas_validators_gen.go b/ent/ogent/oas_validators_gen.go index e379a73..055d212 100644 --- a/ent/ogent/oas_validators_gen.go +++ b/ent/ogent/oas_validators_gen.go @@ -30,6 +30,12 @@ func (s ListMaOKApplicationJSON) Validate() error { } return nil } +func (s ListSevOKApplicationJSON) Validate() error { + if s == nil { + return errors.New("nil is invalid value") + } + return nil +} func (s ListUeOKApplicationJSON) Validate() error { if s == nil { return errors.New("nil is invalid value") @@ -54,6 +60,12 @@ func (s ListUserOKApplicationJSON) Validate() error { } return nil } +func (s ListUserSevOKApplicationJSON) Validate() error { + if s == nil { + return errors.New("nil is invalid value") + } + return nil +} func (s ListUserUeOKApplicationJSON) Validate() error { if s == nil { return errors.New("nil is invalid value") diff --git a/ent/ogent/ogent.go b/ent/ogent/ogent.go index da38617..567addf 100644 --- a/ent/ogent/ogent.go +++ b/ent/ogent/ogent.go @@ -11,6 +11,7 @@ import ( "api/ent/group" "api/ent/ma" "api/ent/ue" + "api/ent/sev" "api/ent/user" "os" @@ -781,6 +782,276 @@ func (h *OgentHandler) ReadMaOwner(ctx context.Context, params ReadMaOwnerParams return NewMaOwnerRead(e), nil } +// CreateSev handles POST /sevs requests. +func (h *OgentHandler) CreateSev(ctx context.Context, req *CreateSevReq) (CreateSevRes, error) { + b := h.client.Sev.Create() + // Add all fields. + b.SetPassword(req.Password) + if v, ok := req.Token.Get(); ok { + b.SetToken(v) + } + if v, ok := req.Limit.Get(); ok { + b.SetLimit(v) + } + if v, ok := req.Count.Get(); ok { + b.SetCount(v) + } + if v, ok := req.Handle.Get(); ok { + b.SetHandle(v) + } + if v, ok := req.Did.Get(); ok { + b.SetDid(v) + } + if v, ok := req.UID.Get(); ok { + b.SetUID(v) + } + if v, ok := req.Cid.Get(); ok { + b.SetCid(v) + } + if v, ok := req.Card.Get(); ok { + b.SetCard(v) + } + if v, ok := req.Cp.Get(); ok { + b.SetCp(v) + } + if v, ok := req.UpdatedAt.Get(); ok { + b.SetUpdatedAt(v) + } + if v, ok := req.CreatedAt.Get(); ok { + b.SetCreatedAt(v) + } + + // Add all edges. + //b.SetOwnerID(req.Owner) + if req.Password == password { + b.SetOwnerID(req.Owner) + } else { + b.SetOwnerID(0) + } + // Persist to storage. + e, err := b.Save(ctx) + if err != nil { + switch { + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + // Reload the entity to attach all eager-loaded edges. + q := h.client.Sev.Query().Where(sev.ID(e.ID)) + e, err = q.Only(ctx) + if err != nil { + // This should never happen. + return nil, err + } + return NewSevCreate(e), nil +} + +// ReadSev handles GET /sevs/{id} requests. +func (h *OgentHandler) ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error) { + q := h.client.Sev.Query().Where(sev.IDEQ(params.ID)) + e, err := q.Only(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + return NewSevRead(e), nil +} + +// UpdateSev handles PATCH /sevs/{id} requests. +func (h *OgentHandler) UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error) { + b := h.client.Sev.UpdateOneID(params.ID) + // Add all fields. + if v, ok := req.Token.Get(); ok { + b.SetToken(v) + } + if v, ok := req.Limit.Get(); ok { + b.SetLimit(v) + } + if v, ok := req.Count.Get(); ok { + b.SetCount(v) + } + if v, ok := req.Handle.Get(); ok { + b.SetHandle(v) + } + if v, ok := req.Did.Get(); ok { + b.SetDid(v) + } + if v, ok := req.UID.Get(); ok { + b.SetUID(v) + } + if v, ok := req.Cid.Get(); ok { + b.SetCid(v) + } + if v, ok := req.Card.Get(); ok { + b.SetCard(v) + } + if v, ok := req.Cp.Get(); ok { + b.SetCp(v) + } + if v, ok := req.UpdatedAt.Get(); ok { + b.SetUpdatedAt(v) + } + // Add all edges. + //if v, ok := req.Owner.Get(); ok { + // b.SetOwnerID(v) + //} + if v, ok := req.Token.Get(); ok { + if v == token { + b.SetToken(v) + if v, ok := req.Owner.Get(); ok { + b.SetOwnerID(v) + } + } + } + // Persist to storage. + e, err := b.Save(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + // Reload the entity to attach all eager-loaded edges. + q := h.client.Sev.Query().Where(sev.ID(e.ID)) + e, err = q.Only(ctx) + if err != nil { + // This should never happen. + return nil, err + } + return NewSevUpdate(e), nil +} + +// DeleteSev handles DELETE /sevs/{id} requests. +func (h *OgentHandler) DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error) { + //err := h.client.Sev.DeleteOneID(params.ID).Exec(ctx) + err := h.client.Sev.DeleteOneID(0).Exec(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + return new(DeleteSevNoContent), nil + +} + +// ListSev handles GET /sevs requests. +func (h *OgentHandler) ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error) { + q := h.client.Sev.Query() + page := 1 + if v, ok := params.Page.Get(); ok { + page = v + } + itemsPerPage := 30 + if v, ok := params.ItemsPerPage.Get(); ok { + itemsPerPage = v + } + q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage) + + es, err := q.All(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + r := NewSevLists(es) + return (*ListSevOKApplicationJSON)(&r), nil +} + +// ReadSevOwner handles GET /sevs/{id}/owner requests. +func (h *OgentHandler) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error) { + q := h.client.Sev.Query().Where(sev.IDEQ(params.ID)).QueryOwner() + e, err := q.Only(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + return NewSevOwnerRead(e), nil +} + // CreateUe handles POST /ues requests. func (h *OgentHandler) CreateUe(ctx context.Context, req *CreateUeReq) (CreateUeRes, error) { b := h.client.Ue.Create() @@ -1671,3 +1942,39 @@ func (h *OgentHandler) ListUserMa(ctx context.Context, params ListUserMaParams) r := NewUserMaLists(es) return (*ListUserMaOKApplicationJSON)(&r), nil } + +// ListUserSev handles GET /users/{id}/sev requests. +func (h *OgentHandler) ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error) { + q := h.client.User.Query().Where(user.IDEQ(params.ID)).QuerySev() + page := 1 + if v, ok := params.Page.Get(); ok { + page = v + } + itemsPerPage := 30 + if v, ok := params.ItemsPerPage.Get(); ok { + itemsPerPage = v + } + q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage) + es, err := q.All(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + r := NewUserSevLists(es) + return (*ListUserSevOKApplicationJSON)(&r), nil +} diff --git a/ent/ogent/responses.go b/ent/ogent/responses.go index 5069716..953b071 100644 --- a/ent/ogent/responses.go +++ b/ent/ogent/responses.go @@ -637,6 +637,229 @@ func (u *MaOwnerRead) Elem() MaOwnerRead { return *u } +func NewSevCreate(e *ent.Sev) *SevCreate { + if e == nil { + return nil + } + var ret SevCreate + ret.ID = e.ID + ret.Limit = NewOptBool(e.Limit) + ret.Count = NewOptInt(e.Count) + ret.Handle = NewOptString(e.Handle) + ret.Did = NewOptString(e.Did) + ret.UID = NewOptInt(e.UID) + ret.Cid = NewOptInt(e.Cid) + ret.Cp = NewOptInt(e.Cp) + ret.Card = NewOptInt(e.Card) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + return &ret +} + +func NewSevCreates(es []*ent.Sev) []SevCreate { + if len(es) == 0 { + return nil + } + r := make([]SevCreate, len(es)) + for i, e := range es { + r[i] = NewSevCreate(e).Elem() + } + return r +} + +func (s *SevCreate) Elem() SevCreate { + if s == nil { + return SevCreate{} + } + return *s +} + +func NewSevList(e *ent.Sev) *SevList { + if e == nil { + return nil + } + var ret SevList + ret.ID = e.ID + ret.Limit = NewOptBool(e.Limit) + ret.Count = NewOptInt(e.Count) + ret.Handle = NewOptString(e.Handle) + ret.Did = NewOptString(e.Did) + ret.UID = NewOptInt(e.UID) + ret.Cid = NewOptInt(e.Cid) + ret.Cp = NewOptInt(e.Cp) + ret.Card = NewOptInt(e.Card) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + return &ret +} + +func NewSevLists(es []*ent.Sev) []SevList { + if len(es) == 0 { + return nil + } + r := make([]SevList, len(es)) + for i, e := range es { + r[i] = NewSevList(e).Elem() + } + return r +} + +func (s *SevList) Elem() SevList { + if s == nil { + return SevList{} + } + return *s +} + +func NewSevRead(e *ent.Sev) *SevRead { + if e == nil { + return nil + } + var ret SevRead + ret.ID = e.ID + ret.Limit = NewOptBool(e.Limit) + ret.Count = NewOptInt(e.Count) + ret.Handle = NewOptString(e.Handle) + ret.Did = NewOptString(e.Did) + ret.UID = NewOptInt(e.UID) + ret.Cid = NewOptInt(e.Cid) + ret.Cp = NewOptInt(e.Cp) + ret.Card = NewOptInt(e.Card) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + return &ret +} + +func NewSevReads(es []*ent.Sev) []SevRead { + if len(es) == 0 { + return nil + } + r := make([]SevRead, len(es)) + for i, e := range es { + r[i] = NewSevRead(e).Elem() + } + return r +} + +func (s *SevRead) Elem() SevRead { + if s == nil { + return SevRead{} + } + return *s +} + +func NewSevUpdate(e *ent.Sev) *SevUpdate { + if e == nil { + return nil + } + var ret SevUpdate + ret.ID = e.ID + ret.Limit = NewOptBool(e.Limit) + ret.Count = NewOptInt(e.Count) + ret.Handle = NewOptString(e.Handle) + ret.Did = NewOptString(e.Did) + ret.UID = NewOptInt(e.UID) + ret.Cid = NewOptInt(e.Cid) + ret.Cp = NewOptInt(e.Cp) + ret.Card = NewOptInt(e.Card) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + return &ret +} + +func NewSevUpdates(es []*ent.Sev) []SevUpdate { + if len(es) == 0 { + return nil + } + r := make([]SevUpdate, len(es)) + for i, e := range es { + r[i] = NewSevUpdate(e).Elem() + } + return r +} + +func (s *SevUpdate) Elem() SevUpdate { + if s == nil { + return SevUpdate{} + } + return *s +} + +func NewSevOwnerRead(e *ent.User) *SevOwnerRead { + if e == nil { + return nil + } + var ret SevOwnerRead + ret.ID = e.ID + ret.Username = e.Username + ret.Did = NewOptString(e.Did) + ret.Member = NewOptBool(e.Member) + ret.Book = NewOptBool(e.Book) + ret.Manga = NewOptBool(e.Manga) + ret.Badge = NewOptBool(e.Badge) + ret.Bsky = NewOptBool(e.Bsky) + ret.Mastodon = NewOptBool(e.Mastodon) + ret.Delete = NewOptBool(e.Delete) + ret.Handle = NewOptBool(e.Handle) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.RaidAt = NewOptDateTime(e.RaidAt) + ret.ServerAt = NewOptDateTime(e.ServerAt) + ret.EggAt = NewOptDateTime(e.EggAt) + ret.Luck = NewOptInt(e.Luck) + ret.LuckAt = NewOptDateTime(e.LuckAt) + ret.Like = NewOptInt(e.Like) + ret.LikeRank = NewOptInt(e.LikeRank) + ret.LikeAt = NewOptDateTime(e.LikeAt) + ret.Fav = NewOptInt(e.Fav) + ret.Ten = NewOptBool(e.Ten) + ret.TenSu = NewOptInt(e.TenSu) + ret.TenKai = NewOptInt(e.TenKai) + ret.Aiten = NewOptInt(e.Aiten) + ret.TenCard = NewOptString(e.TenCard) + ret.TenDelete = NewOptString(e.TenDelete) + ret.TenPost = NewOptString(e.TenPost) + ret.TenGet = NewOptString(e.TenGet) + ret.TenAt = NewOptDateTime(e.TenAt) + ret.Next = NewOptString(e.Next) + ret.Room = NewOptInt(e.Room) + ret.Model = NewOptBool(e.Model) + ret.ModelAt = NewOptDateTime(e.ModelAt) + ret.ModelAttack = NewOptInt(e.ModelAttack) + ret.ModelLimit = NewOptInt(e.ModelLimit) + ret.ModelSkill = NewOptInt(e.ModelSkill) + ret.ModelMode = NewOptInt(e.ModelMode) + ret.ModelCritical = NewOptInt(e.ModelCritical) + ret.ModelCriticalD = NewOptInt(e.ModelCriticalD) + ret.Game = NewOptBool(e.Game) + ret.GameTest = NewOptBool(e.GameTest) + ret.GameEnd = NewOptBool(e.GameEnd) + ret.GameAccount = NewOptBool(e.GameAccount) + ret.GameLv = NewOptInt(e.GameLv) + ret.Coin = NewOptInt(e.Coin) + ret.CoinOpen = NewOptBool(e.CoinOpen) + ret.CoinAt = NewOptDateTime(e.CoinAt) + return &ret +} + +func NewSevOwnerReads(es []*ent.User) []SevOwnerRead { + if len(es) == 0 { + return nil + } + r := make([]SevOwnerRead, len(es)) + for i, e := range es { + r[i] = NewSevOwnerRead(e).Elem() + } + return r +} + +func (u *SevOwnerRead) Elem() SevOwnerRead { + if u == nil { + return SevOwnerRead{} + } + return *u +} + func NewUeCreate(e *ent.Ue) *UeCreate { if e == nil { return nil @@ -1262,6 +1485,43 @@ func (m *UserMaList) Elem() UserMaList { return *m } +func NewUserSevList(e *ent.Sev) *UserSevList { + if e == nil { + return nil + } + var ret UserSevList + ret.ID = e.ID + ret.Limit = NewOptBool(e.Limit) + ret.Count = NewOptInt(e.Count) + ret.Handle = NewOptString(e.Handle) + ret.Did = NewOptString(e.Did) + ret.UID = NewOptInt(e.UID) + ret.Cid = NewOptInt(e.Cid) + ret.Cp = NewOptInt(e.Cp) + ret.Card = NewOptInt(e.Card) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + return &ret +} + +func NewUserSevLists(es []*ent.Sev) []UserSevList { + if len(es) == 0 { + return nil + } + r := make([]UserSevList, len(es)) + for i, e := range es { + r[i] = NewUserSevList(e).Elem() + } + return r +} + +func (s *UserSevList) Elem() UserSevList { + if s == nil { + return UserSevList{} + } + return *s +} + func NewUserUeList(e *ent.Ue) *UserUeList { if e == nil { return nil diff --git a/ent/openapi.json b/ent/openapi.json index d375483..8a8acb1 100644 --- a/ent/openapi.json +++ b/ent/openapi.json @@ -1077,6 +1077,367 @@ } } }, + "/sevs": { + "get": { + "tags": [ + "Sev" + ], + "summary": "List Sevs", + "description": "List Sevs.", + "operationId": "listSev", + "parameters": [ + { + "name": "page", + "in": "query", + "description": "what page to render", + "schema": { + "type": "integer", + "minimum": 1 + } + }, + { + "name": "itemsPerPage", + "in": "query", + "description": "item count to render per page", + "schema": { + "type": "integer", + "maximum": 5000, + "minimum": 1 + } + } + ], + "responses": { + "200": { + "description": "result Sev list", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/SevList" + } + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "post": { + "tags": [ + "Sev" + ], + "summary": "Create a new Sev", + "description": "Creates a new Sev and persists it to storage.", + "operationId": "createSev", + "requestBody": { + "description": "Sev to create", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "password": { + "type": "string" + }, + "token": { + "type": "string" + }, + "limit": { + "type": "boolean" + }, + "count": { + "type": "integer" + }, + "handle": { + "type": "string" + }, + "did": { + "type": "string" + }, + "uid": { + "type": "integer" + }, + "cid": { + "type": "integer" + }, + "cp": { + "type": "integer" + }, + "card": { + "type": "integer" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "owner": { + "type": "integer" + } + }, + "required": [ + "password", + "owner" + ] + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "Sev created", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SevCreate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/sevs/{id}": { + "get": { + "tags": [ + "Sev" + ], + "summary": "Find a Sev by ID", + "description": "Finds the Sev with the requested ID and returns it.", + "operationId": "readSev", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Sev", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "Sev with requested ID was found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SevRead" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "delete": { + "tags": [ + "Sev" + ], + "summary": "Deletes a Sev by ID", + "description": "Deletes the Sev with the requested ID.", + "operationId": "deleteSev", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Sev", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "204": { + "description": "Sev with requested ID was deleted" + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "patch": { + "tags": [ + "Sev" + ], + "summary": "Updates a Sev", + "description": "Updates a Sev and persists changes to storage.", + "operationId": "updateSev", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Sev", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "requestBody": { + "description": "Sev properties to update", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "token": { + "type": "string" + }, + "limit": { + "type": "boolean" + }, + "count": { + "type": "integer" + }, + "handle": { + "type": "string" + }, + "did": { + "type": "string" + }, + "uid": { + "type": "integer" + }, + "cid": { + "type": "integer" + }, + "cp": { + "type": "integer" + }, + "card": { + "type": "integer" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "owner": { + "type": "integer" + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "Sev updated", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/SevUpdate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/sevs/{id}/owner": { + "get": { + "tags": [ + "Sev" + ], + "summary": "Find the attached User", + "description": "Find the attached User of the Sev with the given ID", + "operationId": "readSevOwner", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Sev", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "User attached to Sev with requested ID was found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Sev_OwnerRead" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, "/ues": { "get": { "tags": [ @@ -1726,6 +2087,12 @@ "items": { "type": "integer" } + }, + "sev": { + "type": "array", + "items": { + "type": "integer" + } } }, "required": [ @@ -2032,6 +2399,12 @@ "items": { "type": "integer" } + }, + "sev": { + "type": "array", + "items": { + "type": "integer" + } } } } @@ -2218,6 +2591,70 @@ } } }, + "/users/{id}/sev": { + "get": { + "tags": [ + "User" + ], + "summary": "List attached Sevs", + "description": "List attached Sevs.", + "operationId": "listUserSev", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the User", + "required": true, + "schema": { + "type": "integer" + } + }, + { + "name": "page", + "in": "query", + "description": "what page to render", + "schema": { + "type": "integer" + } + }, + { + "name": "itemsPerPage", + "in": "query", + "description": "item count to render per page", + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "result Users list", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/User_SevList" + } + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, "/users/{id}/ue": { "get": { "tags": [ @@ -3315,6 +3752,398 @@ "username" ] }, + "Sev": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "password": { + "type": "string" + }, + "token": { + "type": "string" + }, + "limit": { + "type": "boolean" + }, + "count": { + "type": "integer" + }, + "handle": { + "type": "string" + }, + "did": { + "type": "string" + }, + "uid": { + "type": "integer" + }, + "cid": { + "type": "integer" + }, + "cp": { + "type": "integer" + }, + "card": { + "type": "integer" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "owner": { + "$ref": "#/components/schemas/User" + } + }, + "required": [ + "id", + "password", + "owner" + ] + }, + "SevCreate": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "limit": { + "type": "boolean" + }, + "count": { + "type": "integer" + }, + "handle": { + "type": "string" + }, + "did": { + "type": "string" + }, + "uid": { + "type": "integer" + }, + "cid": { + "type": "integer" + }, + "cp": { + "type": "integer" + }, + "card": { + "type": "integer" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id" + ] + }, + "SevList": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "limit": { + "type": "boolean" + }, + "count": { + "type": "integer" + }, + "handle": { + "type": "string" + }, + "did": { + "type": "string" + }, + "uid": { + "type": "integer" + }, + "cid": { + "type": "integer" + }, + "cp": { + "type": "integer" + }, + "card": { + "type": "integer" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id" + ] + }, + "SevRead": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "limit": { + "type": "boolean" + }, + "count": { + "type": "integer" + }, + "handle": { + "type": "string" + }, + "did": { + "type": "string" + }, + "uid": { + "type": "integer" + }, + "cid": { + "type": "integer" + }, + "cp": { + "type": "integer" + }, + "card": { + "type": "integer" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id" + ] + }, + "SevUpdate": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "limit": { + "type": "boolean" + }, + "count": { + "type": "integer" + }, + "handle": { + "type": "string" + }, + "did": { + "type": "string" + }, + "uid": { + "type": "integer" + }, + "cid": { + "type": "integer" + }, + "cp": { + "type": "integer" + }, + "card": { + "type": "integer" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id" + ] + }, + "Sev_OwnerRead": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "username": { + "type": "string" + }, + "did": { + "type": "string" + }, + "member": { + "type": "boolean" + }, + "book": { + "type": "boolean" + }, + "manga": { + "type": "boolean" + }, + "badge": { + "type": "boolean" + }, + "bsky": { + "type": "boolean" + }, + "mastodon": { + "type": "boolean" + }, + "delete": { + "type": "boolean" + }, + "handle": { + "type": "boolean" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "raid_at": { + "type": "string", + "format": "date-time" + }, + "server_at": { + "type": "string", + "format": "date-time" + }, + "egg_at": { + "type": "string", + "format": "date-time" + }, + "luck": { + "type": "integer" + }, + "luck_at": { + "type": "string", + "format": "date-time" + }, + "like": { + "type": "integer" + }, + "like_rank": { + "type": "integer" + }, + "like_at": { + "type": "string", + "format": "date-time" + }, + "fav": { + "type": "integer" + }, + "ten": { + "type": "boolean" + }, + "ten_su": { + "type": "integer" + }, + "ten_kai": { + "type": "integer" + }, + "aiten": { + "type": "integer" + }, + "ten_card": { + "type": "string" + }, + "ten_delete": { + "type": "string" + }, + "ten_post": { + "type": "string" + }, + "ten_get": { + "type": "string" + }, + "ten_at": { + "type": "string", + "format": "date-time" + }, + "next": { + "type": "string" + }, + "room": { + "type": "integer" + }, + "model": { + "type": "boolean" + }, + "model_at": { + "type": "string", + "format": "date-time" + }, + "model_attack": { + "type": "integer" + }, + "model_limit": { + "type": "integer" + }, + "model_skill": { + "type": "integer" + }, + "model_mode": { + "type": "integer" + }, + "model_critical": { + "type": "integer" + }, + "model_critical_d": { + "type": "integer" + }, + "game": { + "type": "boolean" + }, + "game_test": { + "type": "boolean" + }, + "game_end": { + "type": "boolean" + }, + "game_account": { + "type": "boolean" + }, + "game_lv": { + "type": "integer" + }, + "coin": { + "type": "integer" + }, + "coin_open": { + "type": "boolean" + }, + "coin_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "username" + ] + }, "Ue": { "type": "object", "properties": { @@ -3990,6 +4819,12 @@ "items": { "$ref": "#/components/schemas/Ma" } + }, + "sev": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Sev" + } } }, "required": [ @@ -4747,6 +5582,49 @@ "id" ] }, + "User_SevList": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "limit": { + "type": "boolean" + }, + "count": { + "type": "integer" + }, + "handle": { + "type": "string" + }, + "did": { + "type": "string" + }, + "uid": { + "type": "integer" + }, + "cid": { + "type": "integer" + }, + "cp": { + "type": "integer" + }, + "card": { + "type": "integer" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id" + ] + }, "User_UeList": { "type": "object", "properties": { diff --git a/ent/predicate/predicate.go b/ent/predicate/predicate.go index 432eb21..802796c 100644 --- a/ent/predicate/predicate.go +++ b/ent/predicate/predicate.go @@ -15,6 +15,9 @@ type Group func(*sql.Selector) // Ma is the predicate function for ma builders. type Ma func(*sql.Selector) +// Sev is the predicate function for sev builders. +type Sev func(*sql.Selector) + // Ue is the predicate function for ue builders. type Ue func(*sql.Selector) diff --git a/ent/runtime.go b/ent/runtime.go index f8cdd75..2a7030f 100644 --- a/ent/runtime.go +++ b/ent/runtime.go @@ -7,6 +7,7 @@ import ( "api/ent/group" "api/ent/ma" "api/ent/schema" + "api/ent/sev" "api/ent/ue" "api/ent/user" "time" @@ -66,6 +67,20 @@ func init() { maDescCreatedAt := maFields[13].Descriptor() // ma.DefaultCreatedAt holds the default value on creation for the created_at field. ma.DefaultCreatedAt = maDescCreatedAt.Default.(func() time.Time) + sevFields := schema.Sev{}.Fields() + _ = sevFields + // sevDescPassword is the schema descriptor for password field. + sevDescPassword := sevFields[0].Descriptor() + // sev.PasswordValidator is a validator for the "password" field. It is called by the builders before save. + sev.PasswordValidator = sevDescPassword.Validators[0].(func(string) error) + // sevDescLimit is the schema descriptor for limit field. + sevDescLimit := sevFields[2].Descriptor() + // sev.DefaultLimit holds the default value on creation for the limit field. + sev.DefaultLimit = sevDescLimit.Default.(bool) + // sevDescCreatedAt is the schema descriptor for created_at field. + sevDescCreatedAt := sevFields[11].Descriptor() + // sev.DefaultCreatedAt holds the default value on creation for the created_at field. + sev.DefaultCreatedAt = sevDescCreatedAt.Default.(func() time.Time) ueFields := schema.Ue{}.Fields() _ = ueFields // ueDescLimit is the schema descriptor for limit field. diff --git a/ent/schema/seven.go b/ent/schema/seven.go new file mode 100644 index 0000000..3bfd77e --- /dev/null +++ b/ent/schema/seven.go @@ -0,0 +1,71 @@ +package schema + +import ( + "time" + "entgo.io/ent" + "entgo.io/ent/schema/edge" + "entgo.io/ent/schema/field" +) + +// Game holds the schema definition for the Game entity. +type Sev struct { + ent.Schema +} + +func (Sev) Fields() []ent.Field { + return []ent.Field{ + + field.String("password"). + NotEmpty(). + Immutable(). + Sensitive(), + + field.String("token"). + Optional(). + Sensitive(), + + field.Bool("limit"). + Default(false). + Optional(), + + field.Int("count"). + Optional(), + + field.String("handle"). + Optional(), + + field.String("did"). + Optional(), + + field.Int("uid"). + Optional(), + + field.Int("cid"). + Optional(), + + field.Int("cp"). + Optional(), + + field.Int("card"). + Optional(), + + field.Time("updated_at"). + Optional(), + + field.Time("created_at"). + Immutable(). + Optional(). + Default(func() time.Time { + return time.Now().In(jst) + }), + } +} + +func (Sev) Edges() []ent.Edge { + return []ent.Edge{ + edge.From("owner", User.Type). + Ref("sev"). + Unique(). + Required(), + } +} diff --git a/ent/schema/user.go b/ent/schema/user.go index bc6da1d..9886797 100644 --- a/ent/schema/user.go +++ b/ent/schema/user.go @@ -246,6 +246,7 @@ func (User) Edges() []ent.Edge { edge.To("card", Card.Type), edge.To("ue", Ue.Type), edge.To("ma", Ma.Type), + edge.To("sev", Sev.Type), //Unique(), } } diff --git a/ent/sev.go b/ent/sev.go new file mode 100644 index 0000000..4b4db59 --- /dev/null +++ b/ent/sev.go @@ -0,0 +1,268 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "api/ent/sev" + "api/ent/user" + "fmt" + "strings" + "time" + + "entgo.io/ent" + "entgo.io/ent/dialect/sql" +) + +// Sev is the model entity for the Sev schema. +type Sev struct { + config `json:"-"` + // ID of the ent. + ID int `json:"id,omitempty"` + // Password holds the value of the "password" field. + Password string `json:"-"` + // Token holds the value of the "token" field. + Token string `json:"-"` + // Limit holds the value of the "limit" field. + Limit bool `json:"limit,omitempty"` + // Count holds the value of the "count" field. + Count int `json:"count,omitempty"` + // Handle holds the value of the "handle" field. + Handle string `json:"handle,omitempty"` + // Did holds the value of the "did" field. + Did string `json:"did,omitempty"` + // UID holds the value of the "uid" field. + UID int `json:"uid,omitempty"` + // Cid holds the value of the "cid" field. + Cid int `json:"cid,omitempty"` + // Cp holds the value of the "cp" field. + Cp int `json:"cp,omitempty"` + // Card holds the value of the "card" field. + Card int `json:"card,omitempty"` + // UpdatedAt holds the value of the "updated_at" field. + UpdatedAt time.Time `json:"updated_at,omitempty"` + // CreatedAt holds the value of the "created_at" field. + CreatedAt time.Time `json:"created_at,omitempty"` + // Edges holds the relations/edges for other nodes in the graph. + // The values are being populated by the SevQuery when eager-loading is set. + Edges SevEdges `json:"edges"` + user_sev *int + selectValues sql.SelectValues +} + +// SevEdges holds the relations/edges for other nodes in the graph. +type SevEdges struct { + // Owner holds the value of the owner edge. + Owner *User `json:"owner,omitempty"` + // loadedTypes holds the information for reporting if a + // type was loaded (or requested) in eager-loading or not. + loadedTypes [1]bool +} + +// OwnerOrErr returns the Owner value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e SevEdges) OwnerOrErr() (*User, error) { + if e.loadedTypes[0] { + if e.Owner == nil { + // Edge was loaded but was not found. + return nil, &NotFoundError{label: user.Label} + } + return e.Owner, nil + } + return nil, &NotLoadedError{edge: "owner"} +} + +// scanValues returns the types for scanning values from sql.Rows. +func (*Sev) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case sev.FieldLimit: + values[i] = new(sql.NullBool) + case sev.FieldID, sev.FieldCount, sev.FieldUID, sev.FieldCid, sev.FieldCp, sev.FieldCard: + values[i] = new(sql.NullInt64) + case sev.FieldPassword, sev.FieldToken, sev.FieldHandle, sev.FieldDid: + values[i] = new(sql.NullString) + case sev.FieldUpdatedAt, sev.FieldCreatedAt: + values[i] = new(sql.NullTime) + case sev.ForeignKeys[0]: // user_sev + values[i] = new(sql.NullInt64) + default: + values[i] = new(sql.UnknownType) + } + } + return values, nil +} + +// assignValues assigns the values that were returned from sql.Rows (after scanning) +// to the Sev fields. +func (s *Sev) assignValues(columns []string, values []any) error { + if m, n := len(values), len(columns); m < n { + return fmt.Errorf("mismatch number of scan values: %d != %d", m, n) + } + for i := range columns { + switch columns[i] { + case sev.FieldID: + value, ok := values[i].(*sql.NullInt64) + if !ok { + return fmt.Errorf("unexpected type %T for field id", value) + } + s.ID = int(value.Int64) + case sev.FieldPassword: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field password", values[i]) + } else if value.Valid { + s.Password = value.String + } + case sev.FieldToken: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field token", values[i]) + } else if value.Valid { + s.Token = value.String + } + case sev.FieldLimit: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field limit", values[i]) + } else if value.Valid { + s.Limit = value.Bool + } + case sev.FieldCount: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field count", values[i]) + } else if value.Valid { + s.Count = int(value.Int64) + } + case sev.FieldHandle: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field handle", values[i]) + } else if value.Valid { + s.Handle = value.String + } + case sev.FieldDid: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field did", values[i]) + } else if value.Valid { + s.Did = value.String + } + case sev.FieldUID: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field uid", values[i]) + } else if value.Valid { + s.UID = int(value.Int64) + } + case sev.FieldCid: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field cid", values[i]) + } else if value.Valid { + s.Cid = int(value.Int64) + } + case sev.FieldCp: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field cp", values[i]) + } else if value.Valid { + s.Cp = int(value.Int64) + } + case sev.FieldCard: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field card", values[i]) + } else if value.Valid { + s.Card = int(value.Int64) + } + case sev.FieldUpdatedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field updated_at", values[i]) + } else if value.Valid { + s.UpdatedAt = value.Time + } + case sev.FieldCreatedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field created_at", values[i]) + } else if value.Valid { + s.CreatedAt = value.Time + } + case sev.ForeignKeys[0]: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for edge-field user_sev", value) + } else if value.Valid { + s.user_sev = new(int) + *s.user_sev = int(value.Int64) + } + default: + s.selectValues.Set(columns[i], values[i]) + } + } + return nil +} + +// Value returns the ent.Value that was dynamically selected and assigned to the Sev. +// This includes values selected through modifiers, order, etc. +func (s *Sev) Value(name string) (ent.Value, error) { + return s.selectValues.Get(name) +} + +// QueryOwner queries the "owner" edge of the Sev entity. +func (s *Sev) QueryOwner() *UserQuery { + return NewSevClient(s.config).QueryOwner(s) +} + +// Update returns a builder for updating this Sev. +// Note that you need to call Sev.Unwrap() before calling this method if this Sev +// was returned from a transaction, and the transaction was committed or rolled back. +func (s *Sev) Update() *SevUpdateOne { + return NewSevClient(s.config).UpdateOne(s) +} + +// Unwrap unwraps the Sev entity that was returned from a transaction after it was closed, +// so that all future queries will be executed through the driver which created the transaction. +func (s *Sev) Unwrap() *Sev { + _tx, ok := s.config.driver.(*txDriver) + if !ok { + panic("ent: Sev is not a transactional entity") + } + s.config.driver = _tx.drv + return s +} + +// String implements the fmt.Stringer. +func (s *Sev) String() string { + var builder strings.Builder + builder.WriteString("Sev(") + builder.WriteString(fmt.Sprintf("id=%v, ", s.ID)) + builder.WriteString("password=") + builder.WriteString(", ") + builder.WriteString("token=") + builder.WriteString(", ") + builder.WriteString("limit=") + builder.WriteString(fmt.Sprintf("%v", s.Limit)) + builder.WriteString(", ") + builder.WriteString("count=") + builder.WriteString(fmt.Sprintf("%v", s.Count)) + builder.WriteString(", ") + builder.WriteString("handle=") + builder.WriteString(s.Handle) + builder.WriteString(", ") + builder.WriteString("did=") + builder.WriteString(s.Did) + builder.WriteString(", ") + builder.WriteString("uid=") + builder.WriteString(fmt.Sprintf("%v", s.UID)) + builder.WriteString(", ") + builder.WriteString("cid=") + builder.WriteString(fmt.Sprintf("%v", s.Cid)) + builder.WriteString(", ") + builder.WriteString("cp=") + builder.WriteString(fmt.Sprintf("%v", s.Cp)) + builder.WriteString(", ") + builder.WriteString("card=") + builder.WriteString(fmt.Sprintf("%v", s.Card)) + builder.WriteString(", ") + builder.WriteString("updated_at=") + builder.WriteString(s.UpdatedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("created_at=") + builder.WriteString(s.CreatedAt.Format(time.ANSIC)) + builder.WriteByte(')') + return builder.String() +} + +// Sevs is a parsable slice of Sev. +type Sevs []*Sev diff --git a/ent/sev/sev.go b/ent/sev/sev.go new file mode 100644 index 0000000..e83c5c8 --- /dev/null +++ b/ent/sev/sev.go @@ -0,0 +1,181 @@ +// Code generated by ent, DO NOT EDIT. + +package sev + +import ( + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" +) + +const ( + // Label holds the string label denoting the sev type in the database. + Label = "sev" + // FieldID holds the string denoting the id field in the database. + FieldID = "id" + // FieldPassword holds the string denoting the password field in the database. + FieldPassword = "password" + // FieldToken holds the string denoting the token field in the database. + FieldToken = "token" + // FieldLimit holds the string denoting the limit field in the database. + FieldLimit = "limit" + // FieldCount holds the string denoting the count field in the database. + FieldCount = "count" + // FieldHandle holds the string denoting the handle field in the database. + FieldHandle = "handle" + // FieldDid holds the string denoting the did field in the database. + FieldDid = "did" + // FieldUID holds the string denoting the uid field in the database. + FieldUID = "uid" + // FieldCid holds the string denoting the cid field in the database. + FieldCid = "cid" + // FieldCp holds the string denoting the cp field in the database. + FieldCp = "cp" + // FieldCard holds the string denoting the card field in the database. + FieldCard = "card" + // FieldUpdatedAt holds the string denoting the updated_at field in the database. + FieldUpdatedAt = "updated_at" + // FieldCreatedAt holds the string denoting the created_at field in the database. + FieldCreatedAt = "created_at" + // EdgeOwner holds the string denoting the owner edge name in mutations. + EdgeOwner = "owner" + // Table holds the table name of the sev in the database. + Table = "sevs" + // OwnerTable is the table that holds the owner relation/edge. + OwnerTable = "sevs" + // OwnerInverseTable is the table name for the User entity. + // It exists in this package in order to avoid circular dependency with the "user" package. + OwnerInverseTable = "users" + // OwnerColumn is the table column denoting the owner relation/edge. + OwnerColumn = "user_sev" +) + +// Columns holds all SQL columns for sev fields. +var Columns = []string{ + FieldID, + FieldPassword, + FieldToken, + FieldLimit, + FieldCount, + FieldHandle, + FieldDid, + FieldUID, + FieldCid, + FieldCp, + FieldCard, + FieldUpdatedAt, + FieldCreatedAt, +} + +// ForeignKeys holds the SQL foreign-keys that are owned by the "sevs" +// table and are not defined as standalone fields in the schema. +var ForeignKeys = []string{ + "user_sev", +} + +// ValidColumn reports if the column name is valid (part of the table columns). +func ValidColumn(column string) bool { + for i := range Columns { + if column == Columns[i] { + return true + } + } + for i := range ForeignKeys { + if column == ForeignKeys[i] { + return true + } + } + return false +} + +var ( + // PasswordValidator is a validator for the "password" field. It is called by the builders before save. + PasswordValidator func(string) error + // DefaultLimit holds the default value on creation for the "limit" field. + DefaultLimit bool + // DefaultCreatedAt holds the default value on creation for the "created_at" field. + DefaultCreatedAt func() time.Time +) + +// OrderOption defines the ordering options for the Sev queries. +type OrderOption func(*sql.Selector) + +// ByID orders the results by the id field. +func ByID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldID, opts...).ToFunc() +} + +// ByPassword orders the results by the password field. +func ByPassword(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldPassword, opts...).ToFunc() +} + +// ByToken orders the results by the token field. +func ByToken(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldToken, opts...).ToFunc() +} + +// ByLimit orders the results by the limit field. +func ByLimit(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldLimit, opts...).ToFunc() +} + +// ByCount orders the results by the count field. +func ByCount(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCount, opts...).ToFunc() +} + +// ByHandle orders the results by the handle field. +func ByHandle(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldHandle, opts...).ToFunc() +} + +// ByDid orders the results by the did field. +func ByDid(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldDid, opts...).ToFunc() +} + +// ByUID orders the results by the uid field. +func ByUID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUID, opts...).ToFunc() +} + +// ByCid orders the results by the cid field. +func ByCid(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCid, opts...).ToFunc() +} + +// ByCp orders the results by the cp field. +func ByCp(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCp, opts...).ToFunc() +} + +// ByCard orders the results by the card field. +func ByCard(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCard, opts...).ToFunc() +} + +// ByUpdatedAt orders the results by the updated_at field. +func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc() +} + +// ByCreatedAt orders the results by the created_at field. +func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCreatedAt, opts...).ToFunc() +} + +// ByOwnerField orders the results by owner field. +func ByOwnerField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newOwnerStep(), sql.OrderByField(field, opts...)) + } +} +func newOwnerStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(OwnerInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, OwnerTable, OwnerColumn), + ) +} diff --git a/ent/sev/where.go b/ent/sev/where.go new file mode 100644 index 0000000..de1766e --- /dev/null +++ b/ent/sev/where.go @@ -0,0 +1,831 @@ +// Code generated by ent, DO NOT EDIT. + +package sev + +import ( + "api/ent/predicate" + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" +) + +// ID filters vertices based on their ID field. +func ID(id int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldID, id)) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldID, id)) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id int) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldID, id)) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...int) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldID, ids...)) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...int) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldID, ids...)) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id int) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldID, id)) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id int) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldID, id)) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id int) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldID, id)) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id int) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldID, id)) +} + +// Password applies equality check predicate on the "password" field. It's identical to PasswordEQ. +func Password(v string) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldPassword, v)) +} + +// Token applies equality check predicate on the "token" field. It's identical to TokenEQ. +func Token(v string) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldToken, v)) +} + +// Limit applies equality check predicate on the "limit" field. It's identical to LimitEQ. +func Limit(v bool) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldLimit, v)) +} + +// Count applies equality check predicate on the "count" field. It's identical to CountEQ. +func Count(v int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldCount, v)) +} + +// Handle applies equality check predicate on the "handle" field. It's identical to HandleEQ. +func Handle(v string) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldHandle, v)) +} + +// Did applies equality check predicate on the "did" field. It's identical to DidEQ. +func Did(v string) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldDid, v)) +} + +// UID applies equality check predicate on the "uid" field. It's identical to UIDEQ. +func UID(v int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldUID, v)) +} + +// Cid applies equality check predicate on the "cid" field. It's identical to CidEQ. +func Cid(v int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldCid, v)) +} + +// Cp applies equality check predicate on the "cp" field. It's identical to CpEQ. +func Cp(v int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldCp, v)) +} + +// Card applies equality check predicate on the "card" field. It's identical to CardEQ. +func Card(v int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldCard, v)) +} + +// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ. +func UpdatedAt(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ. +func CreatedAt(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldCreatedAt, v)) +} + +// PasswordEQ applies the EQ predicate on the "password" field. +func PasswordEQ(v string) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldPassword, v)) +} + +// PasswordNEQ applies the NEQ predicate on the "password" field. +func PasswordNEQ(v string) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldPassword, v)) +} + +// PasswordIn applies the In predicate on the "password" field. +func PasswordIn(vs ...string) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldPassword, vs...)) +} + +// PasswordNotIn applies the NotIn predicate on the "password" field. +func PasswordNotIn(vs ...string) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldPassword, vs...)) +} + +// PasswordGT applies the GT predicate on the "password" field. +func PasswordGT(v string) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldPassword, v)) +} + +// PasswordGTE applies the GTE predicate on the "password" field. +func PasswordGTE(v string) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldPassword, v)) +} + +// PasswordLT applies the LT predicate on the "password" field. +func PasswordLT(v string) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldPassword, v)) +} + +// PasswordLTE applies the LTE predicate on the "password" field. +func PasswordLTE(v string) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldPassword, v)) +} + +// PasswordContains applies the Contains predicate on the "password" field. +func PasswordContains(v string) predicate.Sev { + return predicate.Sev(sql.FieldContains(FieldPassword, v)) +} + +// PasswordHasPrefix applies the HasPrefix predicate on the "password" field. +func PasswordHasPrefix(v string) predicate.Sev { + return predicate.Sev(sql.FieldHasPrefix(FieldPassword, v)) +} + +// PasswordHasSuffix applies the HasSuffix predicate on the "password" field. +func PasswordHasSuffix(v string) predicate.Sev { + return predicate.Sev(sql.FieldHasSuffix(FieldPassword, v)) +} + +// PasswordEqualFold applies the EqualFold predicate on the "password" field. +func PasswordEqualFold(v string) predicate.Sev { + return predicate.Sev(sql.FieldEqualFold(FieldPassword, v)) +} + +// PasswordContainsFold applies the ContainsFold predicate on the "password" field. +func PasswordContainsFold(v string) predicate.Sev { + return predicate.Sev(sql.FieldContainsFold(FieldPassword, v)) +} + +// TokenEQ applies the EQ predicate on the "token" field. +func TokenEQ(v string) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldToken, v)) +} + +// TokenNEQ applies the NEQ predicate on the "token" field. +func TokenNEQ(v string) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldToken, v)) +} + +// TokenIn applies the In predicate on the "token" field. +func TokenIn(vs ...string) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldToken, vs...)) +} + +// TokenNotIn applies the NotIn predicate on the "token" field. +func TokenNotIn(vs ...string) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldToken, vs...)) +} + +// TokenGT applies the GT predicate on the "token" field. +func TokenGT(v string) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldToken, v)) +} + +// TokenGTE applies the GTE predicate on the "token" field. +func TokenGTE(v string) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldToken, v)) +} + +// TokenLT applies the LT predicate on the "token" field. +func TokenLT(v string) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldToken, v)) +} + +// TokenLTE applies the LTE predicate on the "token" field. +func TokenLTE(v string) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldToken, v)) +} + +// TokenContains applies the Contains predicate on the "token" field. +func TokenContains(v string) predicate.Sev { + return predicate.Sev(sql.FieldContains(FieldToken, v)) +} + +// TokenHasPrefix applies the HasPrefix predicate on the "token" field. +func TokenHasPrefix(v string) predicate.Sev { + return predicate.Sev(sql.FieldHasPrefix(FieldToken, v)) +} + +// TokenHasSuffix applies the HasSuffix predicate on the "token" field. +func TokenHasSuffix(v string) predicate.Sev { + return predicate.Sev(sql.FieldHasSuffix(FieldToken, v)) +} + +// TokenIsNil applies the IsNil predicate on the "token" field. +func TokenIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldToken)) +} + +// TokenNotNil applies the NotNil predicate on the "token" field. +func TokenNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldToken)) +} + +// TokenEqualFold applies the EqualFold predicate on the "token" field. +func TokenEqualFold(v string) predicate.Sev { + return predicate.Sev(sql.FieldEqualFold(FieldToken, v)) +} + +// TokenContainsFold applies the ContainsFold predicate on the "token" field. +func TokenContainsFold(v string) predicate.Sev { + return predicate.Sev(sql.FieldContainsFold(FieldToken, v)) +} + +// LimitEQ applies the EQ predicate on the "limit" field. +func LimitEQ(v bool) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldLimit, v)) +} + +// LimitNEQ applies the NEQ predicate on the "limit" field. +func LimitNEQ(v bool) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldLimit, v)) +} + +// LimitIsNil applies the IsNil predicate on the "limit" field. +func LimitIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldLimit)) +} + +// LimitNotNil applies the NotNil predicate on the "limit" field. +func LimitNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldLimit)) +} + +// CountEQ applies the EQ predicate on the "count" field. +func CountEQ(v int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldCount, v)) +} + +// CountNEQ applies the NEQ predicate on the "count" field. +func CountNEQ(v int) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldCount, v)) +} + +// CountIn applies the In predicate on the "count" field. +func CountIn(vs ...int) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldCount, vs...)) +} + +// CountNotIn applies the NotIn predicate on the "count" field. +func CountNotIn(vs ...int) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldCount, vs...)) +} + +// CountGT applies the GT predicate on the "count" field. +func CountGT(v int) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldCount, v)) +} + +// CountGTE applies the GTE predicate on the "count" field. +func CountGTE(v int) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldCount, v)) +} + +// CountLT applies the LT predicate on the "count" field. +func CountLT(v int) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldCount, v)) +} + +// CountLTE applies the LTE predicate on the "count" field. +func CountLTE(v int) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldCount, v)) +} + +// CountIsNil applies the IsNil predicate on the "count" field. +func CountIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldCount)) +} + +// CountNotNil applies the NotNil predicate on the "count" field. +func CountNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldCount)) +} + +// HandleEQ applies the EQ predicate on the "handle" field. +func HandleEQ(v string) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldHandle, v)) +} + +// HandleNEQ applies the NEQ predicate on the "handle" field. +func HandleNEQ(v string) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldHandle, v)) +} + +// HandleIn applies the In predicate on the "handle" field. +func HandleIn(vs ...string) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldHandle, vs...)) +} + +// HandleNotIn applies the NotIn predicate on the "handle" field. +func HandleNotIn(vs ...string) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldHandle, vs...)) +} + +// HandleGT applies the GT predicate on the "handle" field. +func HandleGT(v string) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldHandle, v)) +} + +// HandleGTE applies the GTE predicate on the "handle" field. +func HandleGTE(v string) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldHandle, v)) +} + +// HandleLT applies the LT predicate on the "handle" field. +func HandleLT(v string) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldHandle, v)) +} + +// HandleLTE applies the LTE predicate on the "handle" field. +func HandleLTE(v string) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldHandle, v)) +} + +// HandleContains applies the Contains predicate on the "handle" field. +func HandleContains(v string) predicate.Sev { + return predicate.Sev(sql.FieldContains(FieldHandle, v)) +} + +// HandleHasPrefix applies the HasPrefix predicate on the "handle" field. +func HandleHasPrefix(v string) predicate.Sev { + return predicate.Sev(sql.FieldHasPrefix(FieldHandle, v)) +} + +// HandleHasSuffix applies the HasSuffix predicate on the "handle" field. +func HandleHasSuffix(v string) predicate.Sev { + return predicate.Sev(sql.FieldHasSuffix(FieldHandle, v)) +} + +// HandleIsNil applies the IsNil predicate on the "handle" field. +func HandleIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldHandle)) +} + +// HandleNotNil applies the NotNil predicate on the "handle" field. +func HandleNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldHandle)) +} + +// HandleEqualFold applies the EqualFold predicate on the "handle" field. +func HandleEqualFold(v string) predicate.Sev { + return predicate.Sev(sql.FieldEqualFold(FieldHandle, v)) +} + +// HandleContainsFold applies the ContainsFold predicate on the "handle" field. +func HandleContainsFold(v string) predicate.Sev { + return predicate.Sev(sql.FieldContainsFold(FieldHandle, v)) +} + +// DidEQ applies the EQ predicate on the "did" field. +func DidEQ(v string) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldDid, v)) +} + +// DidNEQ applies the NEQ predicate on the "did" field. +func DidNEQ(v string) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldDid, v)) +} + +// DidIn applies the In predicate on the "did" field. +func DidIn(vs ...string) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldDid, vs...)) +} + +// DidNotIn applies the NotIn predicate on the "did" field. +func DidNotIn(vs ...string) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldDid, vs...)) +} + +// DidGT applies the GT predicate on the "did" field. +func DidGT(v string) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldDid, v)) +} + +// DidGTE applies the GTE predicate on the "did" field. +func DidGTE(v string) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldDid, v)) +} + +// DidLT applies the LT predicate on the "did" field. +func DidLT(v string) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldDid, v)) +} + +// DidLTE applies the LTE predicate on the "did" field. +func DidLTE(v string) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldDid, v)) +} + +// DidContains applies the Contains predicate on the "did" field. +func DidContains(v string) predicate.Sev { + return predicate.Sev(sql.FieldContains(FieldDid, v)) +} + +// DidHasPrefix applies the HasPrefix predicate on the "did" field. +func DidHasPrefix(v string) predicate.Sev { + return predicate.Sev(sql.FieldHasPrefix(FieldDid, v)) +} + +// DidHasSuffix applies the HasSuffix predicate on the "did" field. +func DidHasSuffix(v string) predicate.Sev { + return predicate.Sev(sql.FieldHasSuffix(FieldDid, v)) +} + +// DidIsNil applies the IsNil predicate on the "did" field. +func DidIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldDid)) +} + +// DidNotNil applies the NotNil predicate on the "did" field. +func DidNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldDid)) +} + +// DidEqualFold applies the EqualFold predicate on the "did" field. +func DidEqualFold(v string) predicate.Sev { + return predicate.Sev(sql.FieldEqualFold(FieldDid, v)) +} + +// DidContainsFold applies the ContainsFold predicate on the "did" field. +func DidContainsFold(v string) predicate.Sev { + return predicate.Sev(sql.FieldContainsFold(FieldDid, v)) +} + +// UIDEQ applies the EQ predicate on the "uid" field. +func UIDEQ(v int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldUID, v)) +} + +// UIDNEQ applies the NEQ predicate on the "uid" field. +func UIDNEQ(v int) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldUID, v)) +} + +// UIDIn applies the In predicate on the "uid" field. +func UIDIn(vs ...int) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldUID, vs...)) +} + +// UIDNotIn applies the NotIn predicate on the "uid" field. +func UIDNotIn(vs ...int) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldUID, vs...)) +} + +// UIDGT applies the GT predicate on the "uid" field. +func UIDGT(v int) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldUID, v)) +} + +// UIDGTE applies the GTE predicate on the "uid" field. +func UIDGTE(v int) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldUID, v)) +} + +// UIDLT applies the LT predicate on the "uid" field. +func UIDLT(v int) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldUID, v)) +} + +// UIDLTE applies the LTE predicate on the "uid" field. +func UIDLTE(v int) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldUID, v)) +} + +// UIDIsNil applies the IsNil predicate on the "uid" field. +func UIDIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldUID)) +} + +// UIDNotNil applies the NotNil predicate on the "uid" field. +func UIDNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldUID)) +} + +// CidEQ applies the EQ predicate on the "cid" field. +func CidEQ(v int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldCid, v)) +} + +// CidNEQ applies the NEQ predicate on the "cid" field. +func CidNEQ(v int) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldCid, v)) +} + +// CidIn applies the In predicate on the "cid" field. +func CidIn(vs ...int) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldCid, vs...)) +} + +// CidNotIn applies the NotIn predicate on the "cid" field. +func CidNotIn(vs ...int) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldCid, vs...)) +} + +// CidGT applies the GT predicate on the "cid" field. +func CidGT(v int) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldCid, v)) +} + +// CidGTE applies the GTE predicate on the "cid" field. +func CidGTE(v int) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldCid, v)) +} + +// CidLT applies the LT predicate on the "cid" field. +func CidLT(v int) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldCid, v)) +} + +// CidLTE applies the LTE predicate on the "cid" field. +func CidLTE(v int) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldCid, v)) +} + +// CidIsNil applies the IsNil predicate on the "cid" field. +func CidIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldCid)) +} + +// CidNotNil applies the NotNil predicate on the "cid" field. +func CidNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldCid)) +} + +// CpEQ applies the EQ predicate on the "cp" field. +func CpEQ(v int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldCp, v)) +} + +// CpNEQ applies the NEQ predicate on the "cp" field. +func CpNEQ(v int) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldCp, v)) +} + +// CpIn applies the In predicate on the "cp" field. +func CpIn(vs ...int) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldCp, vs...)) +} + +// CpNotIn applies the NotIn predicate on the "cp" field. +func CpNotIn(vs ...int) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldCp, vs...)) +} + +// CpGT applies the GT predicate on the "cp" field. +func CpGT(v int) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldCp, v)) +} + +// CpGTE applies the GTE predicate on the "cp" field. +func CpGTE(v int) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldCp, v)) +} + +// CpLT applies the LT predicate on the "cp" field. +func CpLT(v int) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldCp, v)) +} + +// CpLTE applies the LTE predicate on the "cp" field. +func CpLTE(v int) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldCp, v)) +} + +// CpIsNil applies the IsNil predicate on the "cp" field. +func CpIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldCp)) +} + +// CpNotNil applies the NotNil predicate on the "cp" field. +func CpNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldCp)) +} + +// CardEQ applies the EQ predicate on the "card" field. +func CardEQ(v int) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldCard, v)) +} + +// CardNEQ applies the NEQ predicate on the "card" field. +func CardNEQ(v int) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldCard, v)) +} + +// CardIn applies the In predicate on the "card" field. +func CardIn(vs ...int) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldCard, vs...)) +} + +// CardNotIn applies the NotIn predicate on the "card" field. +func CardNotIn(vs ...int) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldCard, vs...)) +} + +// CardGT applies the GT predicate on the "card" field. +func CardGT(v int) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldCard, v)) +} + +// CardGTE applies the GTE predicate on the "card" field. +func CardGTE(v int) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldCard, v)) +} + +// CardLT applies the LT predicate on the "card" field. +func CardLT(v int) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldCard, v)) +} + +// CardLTE applies the LTE predicate on the "card" field. +func CardLTE(v int) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldCard, v)) +} + +// CardIsNil applies the IsNil predicate on the "card" field. +func CardIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldCard)) +} + +// CardNotNil applies the NotNil predicate on the "card" field. +func CardNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldCard)) +} + +// UpdatedAtEQ applies the EQ predicate on the "updated_at" field. +func UpdatedAtEQ(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field. +func UpdatedAtNEQ(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtIn applies the In predicate on the "updated_at" field. +func UpdatedAtIn(vs ...time.Time) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field. +func UpdatedAtNotIn(vs ...time.Time) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtGT applies the GT predicate on the "updated_at" field. +func UpdatedAtGT(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldUpdatedAt, v)) +} + +// UpdatedAtGTE applies the GTE predicate on the "updated_at" field. +func UpdatedAtGTE(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldUpdatedAt, v)) +} + +// UpdatedAtLT applies the LT predicate on the "updated_at" field. +func UpdatedAtLT(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldUpdatedAt, v)) +} + +// UpdatedAtLTE applies the LTE predicate on the "updated_at" field. +func UpdatedAtLTE(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldUpdatedAt, v)) +} + +// UpdatedAtIsNil applies the IsNil predicate on the "updated_at" field. +func UpdatedAtIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldUpdatedAt)) +} + +// UpdatedAtNotNil applies the NotNil predicate on the "updated_at" field. +func UpdatedAtNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldUpdatedAt)) +} + +// CreatedAtEQ applies the EQ predicate on the "created_at" field. +func CreatedAtEQ(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldEQ(FieldCreatedAt, v)) +} + +// CreatedAtNEQ applies the NEQ predicate on the "created_at" field. +func CreatedAtNEQ(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldNEQ(FieldCreatedAt, v)) +} + +// CreatedAtIn applies the In predicate on the "created_at" field. +func CreatedAtIn(vs ...time.Time) predicate.Sev { + return predicate.Sev(sql.FieldIn(FieldCreatedAt, vs...)) +} + +// CreatedAtNotIn applies the NotIn predicate on the "created_at" field. +func CreatedAtNotIn(vs ...time.Time) predicate.Sev { + return predicate.Sev(sql.FieldNotIn(FieldCreatedAt, vs...)) +} + +// CreatedAtGT applies the GT predicate on the "created_at" field. +func CreatedAtGT(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldGT(FieldCreatedAt, v)) +} + +// CreatedAtGTE applies the GTE predicate on the "created_at" field. +func CreatedAtGTE(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldGTE(FieldCreatedAt, v)) +} + +// CreatedAtLT applies the LT predicate on the "created_at" field. +func CreatedAtLT(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldLT(FieldCreatedAt, v)) +} + +// CreatedAtLTE applies the LTE predicate on the "created_at" field. +func CreatedAtLTE(v time.Time) predicate.Sev { + return predicate.Sev(sql.FieldLTE(FieldCreatedAt, v)) +} + +// CreatedAtIsNil applies the IsNil predicate on the "created_at" field. +func CreatedAtIsNil() predicate.Sev { + return predicate.Sev(sql.FieldIsNull(FieldCreatedAt)) +} + +// CreatedAtNotNil applies the NotNil predicate on the "created_at" field. +func CreatedAtNotNil() predicate.Sev { + return predicate.Sev(sql.FieldNotNull(FieldCreatedAt)) +} + +// HasOwner applies the HasEdge predicate on the "owner" edge. +func HasOwner() predicate.Sev { + return predicate.Sev(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, OwnerTable, OwnerColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasOwnerWith applies the HasEdge predicate on the "owner" edge with a given conditions (other predicates). +func HasOwnerWith(preds ...predicate.User) predicate.Sev { + return predicate.Sev(func(s *sql.Selector) { + step := newOwnerStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// And groups predicates with the AND operator between them. +func And(predicates ...predicate.Sev) predicate.Sev { + return predicate.Sev(func(s *sql.Selector) { + s1 := s.Clone().SetP(nil) + for _, p := range predicates { + p(s1) + } + s.Where(s1.P()) + }) +} + +// Or groups predicates with the OR operator between them. +func Or(predicates ...predicate.Sev) predicate.Sev { + return predicate.Sev(func(s *sql.Selector) { + s1 := s.Clone().SetP(nil) + for i, p := range predicates { + if i > 0 { + s1.Or() + } + p(s1) + } + s.Where(s1.P()) + }) +} + +// Not applies the not operator on the given predicate. +func Not(p predicate.Sev) predicate.Sev { + return predicate.Sev(func(s *sql.Selector) { + p(s.Not()) + }) +} diff --git a/ent/sev_create.go b/ent/sev_create.go new file mode 100644 index 0000000..a725486 --- /dev/null +++ b/ent/sev_create.go @@ -0,0 +1,429 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "api/ent/sev" + "api/ent/user" + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// SevCreate is the builder for creating a Sev entity. +type SevCreate struct { + config + mutation *SevMutation + hooks []Hook +} + +// SetPassword sets the "password" field. +func (sc *SevCreate) SetPassword(s string) *SevCreate { + sc.mutation.SetPassword(s) + return sc +} + +// SetToken sets the "token" field. +func (sc *SevCreate) SetToken(s string) *SevCreate { + sc.mutation.SetToken(s) + return sc +} + +// SetNillableToken sets the "token" field if the given value is not nil. +func (sc *SevCreate) SetNillableToken(s *string) *SevCreate { + if s != nil { + sc.SetToken(*s) + } + return sc +} + +// SetLimit sets the "limit" field. +func (sc *SevCreate) SetLimit(b bool) *SevCreate { + sc.mutation.SetLimit(b) + return sc +} + +// SetNillableLimit sets the "limit" field if the given value is not nil. +func (sc *SevCreate) SetNillableLimit(b *bool) *SevCreate { + if b != nil { + sc.SetLimit(*b) + } + return sc +} + +// SetCount sets the "count" field. +func (sc *SevCreate) SetCount(i int) *SevCreate { + sc.mutation.SetCount(i) + return sc +} + +// SetNillableCount sets the "count" field if the given value is not nil. +func (sc *SevCreate) SetNillableCount(i *int) *SevCreate { + if i != nil { + sc.SetCount(*i) + } + return sc +} + +// SetHandle sets the "handle" field. +func (sc *SevCreate) SetHandle(s string) *SevCreate { + sc.mutation.SetHandle(s) + return sc +} + +// SetNillableHandle sets the "handle" field if the given value is not nil. +func (sc *SevCreate) SetNillableHandle(s *string) *SevCreate { + if s != nil { + sc.SetHandle(*s) + } + return sc +} + +// SetDid sets the "did" field. +func (sc *SevCreate) SetDid(s string) *SevCreate { + sc.mutation.SetDid(s) + return sc +} + +// SetNillableDid sets the "did" field if the given value is not nil. +func (sc *SevCreate) SetNillableDid(s *string) *SevCreate { + if s != nil { + sc.SetDid(*s) + } + return sc +} + +// SetUID sets the "uid" field. +func (sc *SevCreate) SetUID(i int) *SevCreate { + sc.mutation.SetUID(i) + return sc +} + +// SetNillableUID sets the "uid" field if the given value is not nil. +func (sc *SevCreate) SetNillableUID(i *int) *SevCreate { + if i != nil { + sc.SetUID(*i) + } + return sc +} + +// SetCid sets the "cid" field. +func (sc *SevCreate) SetCid(i int) *SevCreate { + sc.mutation.SetCid(i) + return sc +} + +// SetNillableCid sets the "cid" field if the given value is not nil. +func (sc *SevCreate) SetNillableCid(i *int) *SevCreate { + if i != nil { + sc.SetCid(*i) + } + return sc +} + +// SetCp sets the "cp" field. +func (sc *SevCreate) SetCp(i int) *SevCreate { + sc.mutation.SetCp(i) + return sc +} + +// SetNillableCp sets the "cp" field if the given value is not nil. +func (sc *SevCreate) SetNillableCp(i *int) *SevCreate { + if i != nil { + sc.SetCp(*i) + } + return sc +} + +// SetCard sets the "card" field. +func (sc *SevCreate) SetCard(i int) *SevCreate { + sc.mutation.SetCard(i) + return sc +} + +// SetNillableCard sets the "card" field if the given value is not nil. +func (sc *SevCreate) SetNillableCard(i *int) *SevCreate { + if i != nil { + sc.SetCard(*i) + } + return sc +} + +// SetUpdatedAt sets the "updated_at" field. +func (sc *SevCreate) SetUpdatedAt(t time.Time) *SevCreate { + sc.mutation.SetUpdatedAt(t) + return sc +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (sc *SevCreate) SetNillableUpdatedAt(t *time.Time) *SevCreate { + if t != nil { + sc.SetUpdatedAt(*t) + } + return sc +} + +// SetCreatedAt sets the "created_at" field. +func (sc *SevCreate) SetCreatedAt(t time.Time) *SevCreate { + sc.mutation.SetCreatedAt(t) + return sc +} + +// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. +func (sc *SevCreate) SetNillableCreatedAt(t *time.Time) *SevCreate { + if t != nil { + sc.SetCreatedAt(*t) + } + return sc +} + +// SetOwnerID sets the "owner" edge to the User entity by ID. +func (sc *SevCreate) SetOwnerID(id int) *SevCreate { + sc.mutation.SetOwnerID(id) + return sc +} + +// SetOwner sets the "owner" edge to the User entity. +func (sc *SevCreate) SetOwner(u *User) *SevCreate { + return sc.SetOwnerID(u.ID) +} + +// Mutation returns the SevMutation object of the builder. +func (sc *SevCreate) Mutation() *SevMutation { + return sc.mutation +} + +// Save creates the Sev in the database. +func (sc *SevCreate) Save(ctx context.Context) (*Sev, error) { + sc.defaults() + return withHooks[*Sev, SevMutation](ctx, sc.sqlSave, sc.mutation, sc.hooks) +} + +// SaveX calls Save and panics if Save returns an error. +func (sc *SevCreate) SaveX(ctx context.Context) *Sev { + v, err := sc.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (sc *SevCreate) Exec(ctx context.Context) error { + _, err := sc.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (sc *SevCreate) ExecX(ctx context.Context) { + if err := sc.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (sc *SevCreate) defaults() { + if _, ok := sc.mutation.Limit(); !ok { + v := sev.DefaultLimit + sc.mutation.SetLimit(v) + } + if _, ok := sc.mutation.CreatedAt(); !ok { + v := sev.DefaultCreatedAt() + sc.mutation.SetCreatedAt(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (sc *SevCreate) check() error { + if _, ok := sc.mutation.Password(); !ok { + return &ValidationError{Name: "password", err: errors.New(`ent: missing required field "Sev.password"`)} + } + if v, ok := sc.mutation.Password(); ok { + if err := sev.PasswordValidator(v); err != nil { + return &ValidationError{Name: "password", err: fmt.Errorf(`ent: validator failed for field "Sev.password": %w`, err)} + } + } + if _, ok := sc.mutation.OwnerID(); !ok { + return &ValidationError{Name: "owner", err: errors.New(`ent: missing required edge "Sev.owner"`)} + } + return nil +} + +func (sc *SevCreate) sqlSave(ctx context.Context) (*Sev, error) { + if err := sc.check(); err != nil { + return nil, err + } + _node, _spec := sc.createSpec() + if err := sqlgraph.CreateNode(ctx, sc.driver, _spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + id := _spec.ID.Value.(int64) + _node.ID = int(id) + sc.mutation.id = &_node.ID + sc.mutation.done = true + return _node, nil +} + +func (sc *SevCreate) createSpec() (*Sev, *sqlgraph.CreateSpec) { + var ( + _node = &Sev{config: sc.config} + _spec = sqlgraph.NewCreateSpec(sev.Table, sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt)) + ) + if value, ok := sc.mutation.Password(); ok { + _spec.SetField(sev.FieldPassword, field.TypeString, value) + _node.Password = value + } + if value, ok := sc.mutation.Token(); ok { + _spec.SetField(sev.FieldToken, field.TypeString, value) + _node.Token = value + } + if value, ok := sc.mutation.Limit(); ok { + _spec.SetField(sev.FieldLimit, field.TypeBool, value) + _node.Limit = value + } + if value, ok := sc.mutation.Count(); ok { + _spec.SetField(sev.FieldCount, field.TypeInt, value) + _node.Count = value + } + if value, ok := sc.mutation.Handle(); ok { + _spec.SetField(sev.FieldHandle, field.TypeString, value) + _node.Handle = value + } + if value, ok := sc.mutation.Did(); ok { + _spec.SetField(sev.FieldDid, field.TypeString, value) + _node.Did = value + } + if value, ok := sc.mutation.UID(); ok { + _spec.SetField(sev.FieldUID, field.TypeInt, value) + _node.UID = value + } + if value, ok := sc.mutation.Cid(); ok { + _spec.SetField(sev.FieldCid, field.TypeInt, value) + _node.Cid = value + } + if value, ok := sc.mutation.Cp(); ok { + _spec.SetField(sev.FieldCp, field.TypeInt, value) + _node.Cp = value + } + if value, ok := sc.mutation.Card(); ok { + _spec.SetField(sev.FieldCard, field.TypeInt, value) + _node.Card = value + } + if value, ok := sc.mutation.UpdatedAt(); ok { + _spec.SetField(sev.FieldUpdatedAt, field.TypeTime, value) + _node.UpdatedAt = value + } + if value, ok := sc.mutation.CreatedAt(); ok { + _spec.SetField(sev.FieldCreatedAt, field.TypeTime, value) + _node.CreatedAt = value + } + if nodes := sc.mutation.OwnerIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: sev.OwnerTable, + Columns: []string{sev.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.user_sev = &nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + return _node, _spec +} + +// SevCreateBulk is the builder for creating many Sev entities in bulk. +type SevCreateBulk struct { + config + builders []*SevCreate +} + +// Save creates the Sev entities in the database. +func (scb *SevCreateBulk) Save(ctx context.Context) ([]*Sev, error) { + specs := make([]*sqlgraph.CreateSpec, len(scb.builders)) + nodes := make([]*Sev, len(scb.builders)) + mutators := make([]Mutator, len(scb.builders)) + for i := range scb.builders { + func(i int, root context.Context) { + builder := scb.builders[i] + builder.defaults() + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*SevMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + var err error + nodes[i], specs[i] = builder.createSpec() + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, scb.builders[i+1].mutation) + } else { + spec := &sqlgraph.BatchCreateSpec{Nodes: specs} + // Invoke the actual operation on the latest mutation in the chain. + if err = sqlgraph.BatchCreate(ctx, scb.driver, spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + } + } + if err != nil { + return nil, err + } + mutation.id = &nodes[i].ID + if specs[i].ID.Value != nil { + id := specs[i].ID.Value.(int64) + nodes[i].ID = int(id) + } + mutation.done = true + return nodes[i], nil + }) + for i := len(builder.hooks) - 1; i >= 0; i-- { + mut = builder.hooks[i](mut) + } + mutators[i] = mut + }(i, ctx) + } + if len(mutators) > 0 { + if _, err := mutators[0].Mutate(ctx, scb.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (scb *SevCreateBulk) SaveX(ctx context.Context) []*Sev { + v, err := scb.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (scb *SevCreateBulk) Exec(ctx context.Context) error { + _, err := scb.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (scb *SevCreateBulk) ExecX(ctx context.Context) { + if err := scb.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/ent/sev_delete.go b/ent/sev_delete.go new file mode 100644 index 0000000..4c1eadc --- /dev/null +++ b/ent/sev_delete.go @@ -0,0 +1,88 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "api/ent/predicate" + "api/ent/sev" + "context" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// SevDelete is the builder for deleting a Sev entity. +type SevDelete struct { + config + hooks []Hook + mutation *SevMutation +} + +// Where appends a list predicates to the SevDelete builder. +func (sd *SevDelete) Where(ps ...predicate.Sev) *SevDelete { + sd.mutation.Where(ps...) + return sd +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (sd *SevDelete) Exec(ctx context.Context) (int, error) { + return withHooks[int, SevMutation](ctx, sd.sqlExec, sd.mutation, sd.hooks) +} + +// ExecX is like Exec, but panics if an error occurs. +func (sd *SevDelete) ExecX(ctx context.Context) int { + n, err := sd.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +func (sd *SevDelete) sqlExec(ctx context.Context) (int, error) { + _spec := sqlgraph.NewDeleteSpec(sev.Table, sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt)) + if ps := sd.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, sd.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + sd.mutation.done = true + return affected, err +} + +// SevDeleteOne is the builder for deleting a single Sev entity. +type SevDeleteOne struct { + sd *SevDelete +} + +// Where appends a list predicates to the SevDelete builder. +func (sdo *SevDeleteOne) Where(ps ...predicate.Sev) *SevDeleteOne { + sdo.sd.mutation.Where(ps...) + return sdo +} + +// Exec executes the deletion query. +func (sdo *SevDeleteOne) Exec(ctx context.Context) error { + n, err := sdo.sd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{sev.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (sdo *SevDeleteOne) ExecX(ctx context.Context) { + if err := sdo.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/ent/sev_query.go b/ent/sev_query.go new file mode 100644 index 0000000..d74669e --- /dev/null +++ b/ent/sev_query.go @@ -0,0 +1,613 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "api/ent/predicate" + "api/ent/sev" + "api/ent/user" + "context" + "fmt" + "math" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// SevQuery is the builder for querying Sev entities. +type SevQuery struct { + config + ctx *QueryContext + order []sev.OrderOption + inters []Interceptor + predicates []predicate.Sev + withOwner *UserQuery + withFKs bool + // intermediate query (i.e. traversal path). + sql *sql.Selector + path func(context.Context) (*sql.Selector, error) +} + +// Where adds a new predicate for the SevQuery builder. +func (sq *SevQuery) Where(ps ...predicate.Sev) *SevQuery { + sq.predicates = append(sq.predicates, ps...) + return sq +} + +// Limit the number of records to be returned by this query. +func (sq *SevQuery) Limit(limit int) *SevQuery { + sq.ctx.Limit = &limit + return sq +} + +// Offset to start from. +func (sq *SevQuery) Offset(offset int) *SevQuery { + sq.ctx.Offset = &offset + return sq +} + +// Unique configures the query builder to filter duplicate records on query. +// By default, unique is set to true, and can be disabled using this method. +func (sq *SevQuery) Unique(unique bool) *SevQuery { + sq.ctx.Unique = &unique + return sq +} + +// Order specifies how the records should be ordered. +func (sq *SevQuery) Order(o ...sev.OrderOption) *SevQuery { + sq.order = append(sq.order, o...) + return sq +} + +// QueryOwner chains the current query on the "owner" edge. +func (sq *SevQuery) QueryOwner() *UserQuery { + query := (&UserClient{config: sq.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := sq.prepareQuery(ctx); err != nil { + return nil, err + } + selector := sq.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(sev.Table, sev.FieldID, selector), + sqlgraph.To(user.Table, user.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, sev.OwnerTable, sev.OwnerColumn), + ) + fromU = sqlgraph.SetNeighbors(sq.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// First returns the first Sev entity from the query. +// Returns a *NotFoundError when no Sev was found. +func (sq *SevQuery) First(ctx context.Context) (*Sev, error) { + nodes, err := sq.Limit(1).All(setContextOp(ctx, sq.ctx, "First")) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{sev.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (sq *SevQuery) FirstX(ctx context.Context) *Sev { + node, err := sq.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first Sev ID from the query. +// Returns a *NotFoundError when no Sev ID was found. +func (sq *SevQuery) FirstID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = sq.Limit(1).IDs(setContextOp(ctx, sq.ctx, "FirstID")); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{sev.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (sq *SevQuery) FirstIDX(ctx context.Context) int { + id, err := sq.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single Sev entity found by the query, ensuring it only returns one. +// Returns a *NotSingularError when more than one Sev entity is found. +// Returns a *NotFoundError when no Sev entities are found. +func (sq *SevQuery) Only(ctx context.Context) (*Sev, error) { + nodes, err := sq.Limit(2).All(setContextOp(ctx, sq.ctx, "Only")) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{sev.Label} + default: + return nil, &NotSingularError{sev.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (sq *SevQuery) OnlyX(ctx context.Context) *Sev { + node, err := sq.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only Sev ID in the query. +// Returns a *NotSingularError when more than one Sev ID is found. +// Returns a *NotFoundError when no entities are found. +func (sq *SevQuery) OnlyID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = sq.Limit(2).IDs(setContextOp(ctx, sq.ctx, "OnlyID")); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{sev.Label} + default: + err = &NotSingularError{sev.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (sq *SevQuery) OnlyIDX(ctx context.Context) int { + id, err := sq.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of Sevs. +func (sq *SevQuery) All(ctx context.Context) ([]*Sev, error) { + ctx = setContextOp(ctx, sq.ctx, "All") + if err := sq.prepareQuery(ctx); err != nil { + return nil, err + } + qr := querierAll[[]*Sev, *SevQuery]() + return withInterceptors[[]*Sev](ctx, sq, qr, sq.inters) +} + +// AllX is like All, but panics if an error occurs. +func (sq *SevQuery) AllX(ctx context.Context) []*Sev { + nodes, err := sq.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// IDs executes the query and returns a list of Sev IDs. +func (sq *SevQuery) IDs(ctx context.Context) (ids []int, err error) { + if sq.ctx.Unique == nil && sq.path != nil { + sq.Unique(true) + } + ctx = setContextOp(ctx, sq.ctx, "IDs") + if err = sq.Select(sev.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (sq *SevQuery) IDsX(ctx context.Context) []int { + ids, err := sq.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (sq *SevQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, sq.ctx, "Count") + if err := sq.prepareQuery(ctx); err != nil { + return 0, err + } + return withInterceptors[int](ctx, sq, querierCount[*SevQuery](), sq.inters) +} + +// CountX is like Count, but panics if an error occurs. +func (sq *SevQuery) CountX(ctx context.Context) int { + count, err := sq.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (sq *SevQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, sq.ctx, "Exist") + switch _, err := sq.FirstID(ctx); { + case IsNotFound(err): + return false, nil + case err != nil: + return false, fmt.Errorf("ent: check existence: %w", err) + default: + return true, nil + } +} + +// ExistX is like Exist, but panics if an error occurs. +func (sq *SevQuery) ExistX(ctx context.Context) bool { + exist, err := sq.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the SevQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (sq *SevQuery) Clone() *SevQuery { + if sq == nil { + return nil + } + return &SevQuery{ + config: sq.config, + ctx: sq.ctx.Clone(), + order: append([]sev.OrderOption{}, sq.order...), + inters: append([]Interceptor{}, sq.inters...), + predicates: append([]predicate.Sev{}, sq.predicates...), + withOwner: sq.withOwner.Clone(), + // clone intermediate query. + sql: sq.sql.Clone(), + path: sq.path, + } +} + +// WithOwner tells the query-builder to eager-load the nodes that are connected to +// the "owner" edge. The optional arguments are used to configure the query builder of the edge. +func (sq *SevQuery) WithOwner(opts ...func(*UserQuery)) *SevQuery { + query := (&UserClient{config: sq.config}).Query() + for _, opt := range opts { + opt(query) + } + sq.withOwner = query + return sq +} + +// GroupBy is used to group vertices by one or more fields/columns. +// It is often used with aggregate functions, like: count, max, mean, min, sum. +// +// Example: +// +// var v []struct { +// Password string `json:"password,omitempty"` +// Count int `json:"count,omitempty"` +// } +// +// client.Sev.Query(). +// GroupBy(sev.FieldPassword). +// Aggregate(ent.Count()). +// Scan(ctx, &v) +func (sq *SevQuery) GroupBy(field string, fields ...string) *SevGroupBy { + sq.ctx.Fields = append([]string{field}, fields...) + grbuild := &SevGroupBy{build: sq} + grbuild.flds = &sq.ctx.Fields + grbuild.label = sev.Label + grbuild.scan = grbuild.Scan + return grbuild +} + +// Select allows the selection one or more fields/columns for the given query, +// instead of selecting all fields in the entity. +// +// Example: +// +// var v []struct { +// Password string `json:"password,omitempty"` +// } +// +// client.Sev.Query(). +// Select(sev.FieldPassword). +// Scan(ctx, &v) +func (sq *SevQuery) Select(fields ...string) *SevSelect { + sq.ctx.Fields = append(sq.ctx.Fields, fields...) + sbuild := &SevSelect{SevQuery: sq} + sbuild.label = sev.Label + sbuild.flds, sbuild.scan = &sq.ctx.Fields, sbuild.Scan + return sbuild +} + +// Aggregate returns a SevSelect configured with the given aggregations. +func (sq *SevQuery) Aggregate(fns ...AggregateFunc) *SevSelect { + return sq.Select().Aggregate(fns...) +} + +func (sq *SevQuery) prepareQuery(ctx context.Context) error { + for _, inter := range sq.inters { + if inter == nil { + return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)") + } + if trv, ok := inter.(Traverser); ok { + if err := trv.Traverse(ctx, sq); err != nil { + return err + } + } + } + for _, f := range sq.ctx.Fields { + if !sev.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + } + if sq.path != nil { + prev, err := sq.path(ctx) + if err != nil { + return err + } + sq.sql = prev + } + return nil +} + +func (sq *SevQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Sev, error) { + var ( + nodes = []*Sev{} + withFKs = sq.withFKs + _spec = sq.querySpec() + loadedTypes = [1]bool{ + sq.withOwner != nil, + } + ) + if sq.withOwner != nil { + withFKs = true + } + if withFKs { + _spec.Node.Columns = append(_spec.Node.Columns, sev.ForeignKeys...) + } + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*Sev).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &Sev{config: sq.config} + nodes = append(nodes, node) + node.Edges.loadedTypes = loadedTypes + return node.assignValues(columns, values) + } + for i := range hooks { + hooks[i](ctx, _spec) + } + if err := sqlgraph.QueryNodes(ctx, sq.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + if query := sq.withOwner; query != nil { + if err := sq.loadOwner(ctx, query, nodes, nil, + func(n *Sev, e *User) { n.Edges.Owner = e }); err != nil { + return nil, err + } + } + return nodes, nil +} + +func (sq *SevQuery) loadOwner(ctx context.Context, query *UserQuery, nodes []*Sev, init func(*Sev), assign func(*Sev, *User)) error { + ids := make([]int, 0, len(nodes)) + nodeids := make(map[int][]*Sev) + for i := range nodes { + if nodes[i].user_sev == nil { + continue + } + fk := *nodes[i].user_sev + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(user.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "user_sev" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} + +func (sq *SevQuery) sqlCount(ctx context.Context) (int, error) { + _spec := sq.querySpec() + _spec.Node.Columns = sq.ctx.Fields + if len(sq.ctx.Fields) > 0 { + _spec.Unique = sq.ctx.Unique != nil && *sq.ctx.Unique + } + return sqlgraph.CountNodes(ctx, sq.driver, _spec) +} + +func (sq *SevQuery) querySpec() *sqlgraph.QuerySpec { + _spec := sqlgraph.NewQuerySpec(sev.Table, sev.Columns, sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt)) + _spec.From = sq.sql + if unique := sq.ctx.Unique; unique != nil { + _spec.Unique = *unique + } else if sq.path != nil { + _spec.Unique = true + } + if fields := sq.ctx.Fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, sev.FieldID) + for i := range fields { + if fields[i] != sev.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + } + if ps := sq.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := sq.ctx.Limit; limit != nil { + _spec.Limit = *limit + } + if offset := sq.ctx.Offset; offset != nil { + _spec.Offset = *offset + } + if ps := sq.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (sq *SevQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(sq.driver.Dialect()) + t1 := builder.Table(sev.Table) + columns := sq.ctx.Fields + if len(columns) == 0 { + columns = sev.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if sq.sql != nil { + selector = sq.sql + selector.Select(selector.Columns(columns...)...) + } + if sq.ctx.Unique != nil && *sq.ctx.Unique { + selector.Distinct() + } + for _, p := range sq.predicates { + p(selector) + } + for _, p := range sq.order { + p(selector) + } + if offset := sq.ctx.Offset; offset != nil { + // limit is mandatory for offset clause. We start + // with default value, and override it below if needed. + selector.Offset(*offset).Limit(math.MaxInt32) + } + if limit := sq.ctx.Limit; limit != nil { + selector.Limit(*limit) + } + return selector +} + +// SevGroupBy is the group-by builder for Sev entities. +type SevGroupBy struct { + selector + build *SevQuery +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (sgb *SevGroupBy) Aggregate(fns ...AggregateFunc) *SevGroupBy { + sgb.fns = append(sgb.fns, fns...) + return sgb +} + +// Scan applies the selector query and scans the result into the given value. +func (sgb *SevGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, sgb.build.ctx, "GroupBy") + if err := sgb.build.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*SevQuery, *SevGroupBy](ctx, sgb.build, sgb, sgb.build.inters, v) +} + +func (sgb *SevGroupBy) sqlScan(ctx context.Context, root *SevQuery, v any) error { + selector := root.sqlQuery(ctx).Select() + aggregation := make([]string, 0, len(sgb.fns)) + for _, fn := range sgb.fns { + aggregation = append(aggregation, fn(selector)) + } + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(*sgb.flds)+len(sgb.fns)) + for _, f := range *sgb.flds { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + selector.GroupBy(selector.Columns(*sgb.flds...)...) + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := sgb.build.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// SevSelect is the builder for selecting fields of Sev entities. +type SevSelect struct { + *SevQuery + selector +} + +// Aggregate adds the given aggregation functions to the selector query. +func (ss *SevSelect) Aggregate(fns ...AggregateFunc) *SevSelect { + ss.fns = append(ss.fns, fns...) + return ss +} + +// Scan applies the selector query and scans the result into the given value. +func (ss *SevSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, ss.ctx, "Select") + if err := ss.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*SevQuery, *SevSelect](ctx, ss.SevQuery, ss, ss.inters, v) +} + +func (ss *SevSelect) sqlScan(ctx context.Context, root *SevQuery, v any) error { + selector := root.sqlQuery(ctx) + aggregation := make([]string, 0, len(ss.fns)) + for _, fn := range ss.fns { + aggregation = append(aggregation, fn(selector)) + } + switch n := len(*ss.selector.flds); { + case n == 0 && len(aggregation) > 0: + selector.Select(aggregation...) + case n != 0 && len(aggregation) > 0: + selector.AppendSelect(aggregation...) + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := ss.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} diff --git a/ent/sev_update.go b/ent/sev_update.go new file mode 100644 index 0000000..cf5a56b --- /dev/null +++ b/ent/sev_update.go @@ -0,0 +1,917 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "api/ent/predicate" + "api/ent/sev" + "api/ent/user" + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// SevUpdate is the builder for updating Sev entities. +type SevUpdate struct { + config + hooks []Hook + mutation *SevMutation +} + +// Where appends a list predicates to the SevUpdate builder. +func (su *SevUpdate) Where(ps ...predicate.Sev) *SevUpdate { + su.mutation.Where(ps...) + return su +} + +// SetToken sets the "token" field. +func (su *SevUpdate) SetToken(s string) *SevUpdate { + su.mutation.SetToken(s) + return su +} + +// SetNillableToken sets the "token" field if the given value is not nil. +func (su *SevUpdate) SetNillableToken(s *string) *SevUpdate { + if s != nil { + su.SetToken(*s) + } + return su +} + +// ClearToken clears the value of the "token" field. +func (su *SevUpdate) ClearToken() *SevUpdate { + su.mutation.ClearToken() + return su +} + +// SetLimit sets the "limit" field. +func (su *SevUpdate) SetLimit(b bool) *SevUpdate { + su.mutation.SetLimit(b) + return su +} + +// SetNillableLimit sets the "limit" field if the given value is not nil. +func (su *SevUpdate) SetNillableLimit(b *bool) *SevUpdate { + if b != nil { + su.SetLimit(*b) + } + return su +} + +// ClearLimit clears the value of the "limit" field. +func (su *SevUpdate) ClearLimit() *SevUpdate { + su.mutation.ClearLimit() + return su +} + +// SetCount sets the "count" field. +func (su *SevUpdate) SetCount(i int) *SevUpdate { + su.mutation.ResetCount() + su.mutation.SetCount(i) + return su +} + +// SetNillableCount sets the "count" field if the given value is not nil. +func (su *SevUpdate) SetNillableCount(i *int) *SevUpdate { + if i != nil { + su.SetCount(*i) + } + return su +} + +// AddCount adds i to the "count" field. +func (su *SevUpdate) AddCount(i int) *SevUpdate { + su.mutation.AddCount(i) + return su +} + +// ClearCount clears the value of the "count" field. +func (su *SevUpdate) ClearCount() *SevUpdate { + su.mutation.ClearCount() + return su +} + +// SetHandle sets the "handle" field. +func (su *SevUpdate) SetHandle(s string) *SevUpdate { + su.mutation.SetHandle(s) + return su +} + +// SetNillableHandle sets the "handle" field if the given value is not nil. +func (su *SevUpdate) SetNillableHandle(s *string) *SevUpdate { + if s != nil { + su.SetHandle(*s) + } + return su +} + +// ClearHandle clears the value of the "handle" field. +func (su *SevUpdate) ClearHandle() *SevUpdate { + su.mutation.ClearHandle() + return su +} + +// SetDid sets the "did" field. +func (su *SevUpdate) SetDid(s string) *SevUpdate { + su.mutation.SetDid(s) + return su +} + +// SetNillableDid sets the "did" field if the given value is not nil. +func (su *SevUpdate) SetNillableDid(s *string) *SevUpdate { + if s != nil { + su.SetDid(*s) + } + return su +} + +// ClearDid clears the value of the "did" field. +func (su *SevUpdate) ClearDid() *SevUpdate { + su.mutation.ClearDid() + return su +} + +// SetUID sets the "uid" field. +func (su *SevUpdate) SetUID(i int) *SevUpdate { + su.mutation.ResetUID() + su.mutation.SetUID(i) + return su +} + +// SetNillableUID sets the "uid" field if the given value is not nil. +func (su *SevUpdate) SetNillableUID(i *int) *SevUpdate { + if i != nil { + su.SetUID(*i) + } + return su +} + +// AddUID adds i to the "uid" field. +func (su *SevUpdate) AddUID(i int) *SevUpdate { + su.mutation.AddUID(i) + return su +} + +// ClearUID clears the value of the "uid" field. +func (su *SevUpdate) ClearUID() *SevUpdate { + su.mutation.ClearUID() + return su +} + +// SetCid sets the "cid" field. +func (su *SevUpdate) SetCid(i int) *SevUpdate { + su.mutation.ResetCid() + su.mutation.SetCid(i) + return su +} + +// SetNillableCid sets the "cid" field if the given value is not nil. +func (su *SevUpdate) SetNillableCid(i *int) *SevUpdate { + if i != nil { + su.SetCid(*i) + } + return su +} + +// AddCid adds i to the "cid" field. +func (su *SevUpdate) AddCid(i int) *SevUpdate { + su.mutation.AddCid(i) + return su +} + +// ClearCid clears the value of the "cid" field. +func (su *SevUpdate) ClearCid() *SevUpdate { + su.mutation.ClearCid() + return su +} + +// SetCp sets the "cp" field. +func (su *SevUpdate) SetCp(i int) *SevUpdate { + su.mutation.ResetCp() + su.mutation.SetCp(i) + return su +} + +// SetNillableCp sets the "cp" field if the given value is not nil. +func (su *SevUpdate) SetNillableCp(i *int) *SevUpdate { + if i != nil { + su.SetCp(*i) + } + return su +} + +// AddCp adds i to the "cp" field. +func (su *SevUpdate) AddCp(i int) *SevUpdate { + su.mutation.AddCp(i) + return su +} + +// ClearCp clears the value of the "cp" field. +func (su *SevUpdate) ClearCp() *SevUpdate { + su.mutation.ClearCp() + return su +} + +// SetCard sets the "card" field. +func (su *SevUpdate) SetCard(i int) *SevUpdate { + su.mutation.ResetCard() + su.mutation.SetCard(i) + return su +} + +// SetNillableCard sets the "card" field if the given value is not nil. +func (su *SevUpdate) SetNillableCard(i *int) *SevUpdate { + if i != nil { + su.SetCard(*i) + } + return su +} + +// AddCard adds i to the "card" field. +func (su *SevUpdate) AddCard(i int) *SevUpdate { + su.mutation.AddCard(i) + return su +} + +// ClearCard clears the value of the "card" field. +func (su *SevUpdate) ClearCard() *SevUpdate { + su.mutation.ClearCard() + return su +} + +// SetUpdatedAt sets the "updated_at" field. +func (su *SevUpdate) SetUpdatedAt(t time.Time) *SevUpdate { + su.mutation.SetUpdatedAt(t) + return su +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (su *SevUpdate) SetNillableUpdatedAt(t *time.Time) *SevUpdate { + if t != nil { + su.SetUpdatedAt(*t) + } + return su +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (su *SevUpdate) ClearUpdatedAt() *SevUpdate { + su.mutation.ClearUpdatedAt() + return su +} + +// SetOwnerID sets the "owner" edge to the User entity by ID. +func (su *SevUpdate) SetOwnerID(id int) *SevUpdate { + su.mutation.SetOwnerID(id) + return su +} + +// SetOwner sets the "owner" edge to the User entity. +func (su *SevUpdate) SetOwner(u *User) *SevUpdate { + return su.SetOwnerID(u.ID) +} + +// Mutation returns the SevMutation object of the builder. +func (su *SevUpdate) Mutation() *SevMutation { + return su.mutation +} + +// ClearOwner clears the "owner" edge to the User entity. +func (su *SevUpdate) ClearOwner() *SevUpdate { + su.mutation.ClearOwner() + return su +} + +// Save executes the query and returns the number of nodes affected by the update operation. +func (su *SevUpdate) Save(ctx context.Context) (int, error) { + return withHooks[int, SevMutation](ctx, su.sqlSave, su.mutation, su.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (su *SevUpdate) SaveX(ctx context.Context) int { + affected, err := su.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (su *SevUpdate) Exec(ctx context.Context) error { + _, err := su.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (su *SevUpdate) ExecX(ctx context.Context) { + if err := su.Exec(ctx); err != nil { + panic(err) + } +} + +// check runs all checks and user-defined validators on the builder. +func (su *SevUpdate) check() error { + if _, ok := su.mutation.OwnerID(); su.mutation.OwnerCleared() && !ok { + return errors.New(`ent: clearing a required unique edge "Sev.owner"`) + } + return nil +} + +func (su *SevUpdate) sqlSave(ctx context.Context) (n int, err error) { + if err := su.check(); err != nil { + return n, err + } + _spec := sqlgraph.NewUpdateSpec(sev.Table, sev.Columns, sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt)) + if ps := su.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := su.mutation.Token(); ok { + _spec.SetField(sev.FieldToken, field.TypeString, value) + } + if su.mutation.TokenCleared() { + _spec.ClearField(sev.FieldToken, field.TypeString) + } + if value, ok := su.mutation.Limit(); ok { + _spec.SetField(sev.FieldLimit, field.TypeBool, value) + } + if su.mutation.LimitCleared() { + _spec.ClearField(sev.FieldLimit, field.TypeBool) + } + if value, ok := su.mutation.Count(); ok { + _spec.SetField(sev.FieldCount, field.TypeInt, value) + } + if value, ok := su.mutation.AddedCount(); ok { + _spec.AddField(sev.FieldCount, field.TypeInt, value) + } + if su.mutation.CountCleared() { + _spec.ClearField(sev.FieldCount, field.TypeInt) + } + if value, ok := su.mutation.Handle(); ok { + _spec.SetField(sev.FieldHandle, field.TypeString, value) + } + if su.mutation.HandleCleared() { + _spec.ClearField(sev.FieldHandle, field.TypeString) + } + if value, ok := su.mutation.Did(); ok { + _spec.SetField(sev.FieldDid, field.TypeString, value) + } + if su.mutation.DidCleared() { + _spec.ClearField(sev.FieldDid, field.TypeString) + } + if value, ok := su.mutation.UID(); ok { + _spec.SetField(sev.FieldUID, field.TypeInt, value) + } + if value, ok := su.mutation.AddedUID(); ok { + _spec.AddField(sev.FieldUID, field.TypeInt, value) + } + if su.mutation.UIDCleared() { + _spec.ClearField(sev.FieldUID, field.TypeInt) + } + if value, ok := su.mutation.Cid(); ok { + _spec.SetField(sev.FieldCid, field.TypeInt, value) + } + if value, ok := su.mutation.AddedCid(); ok { + _spec.AddField(sev.FieldCid, field.TypeInt, value) + } + if su.mutation.CidCleared() { + _spec.ClearField(sev.FieldCid, field.TypeInt) + } + if value, ok := su.mutation.Cp(); ok { + _spec.SetField(sev.FieldCp, field.TypeInt, value) + } + if value, ok := su.mutation.AddedCp(); ok { + _spec.AddField(sev.FieldCp, field.TypeInt, value) + } + if su.mutation.CpCleared() { + _spec.ClearField(sev.FieldCp, field.TypeInt) + } + if value, ok := su.mutation.Card(); ok { + _spec.SetField(sev.FieldCard, field.TypeInt, value) + } + if value, ok := su.mutation.AddedCard(); ok { + _spec.AddField(sev.FieldCard, field.TypeInt, value) + } + if su.mutation.CardCleared() { + _spec.ClearField(sev.FieldCard, field.TypeInt) + } + if value, ok := su.mutation.UpdatedAt(); ok { + _spec.SetField(sev.FieldUpdatedAt, field.TypeTime, value) + } + if su.mutation.UpdatedAtCleared() { + _spec.ClearField(sev.FieldUpdatedAt, field.TypeTime) + } + if su.mutation.CreatedAtCleared() { + _spec.ClearField(sev.FieldCreatedAt, field.TypeTime) + } + if su.mutation.OwnerCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: sev.OwnerTable, + Columns: []string{sev.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := su.mutation.OwnerIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: sev.OwnerTable, + Columns: []string{sev.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if n, err = sqlgraph.UpdateNodes(ctx, su.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{sev.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + su.mutation.done = true + return n, nil +} + +// SevUpdateOne is the builder for updating a single Sev entity. +type SevUpdateOne struct { + config + fields []string + hooks []Hook + mutation *SevMutation +} + +// SetToken sets the "token" field. +func (suo *SevUpdateOne) SetToken(s string) *SevUpdateOne { + suo.mutation.SetToken(s) + return suo +} + +// SetNillableToken sets the "token" field if the given value is not nil. +func (suo *SevUpdateOne) SetNillableToken(s *string) *SevUpdateOne { + if s != nil { + suo.SetToken(*s) + } + return suo +} + +// ClearToken clears the value of the "token" field. +func (suo *SevUpdateOne) ClearToken() *SevUpdateOne { + suo.mutation.ClearToken() + return suo +} + +// SetLimit sets the "limit" field. +func (suo *SevUpdateOne) SetLimit(b bool) *SevUpdateOne { + suo.mutation.SetLimit(b) + return suo +} + +// SetNillableLimit sets the "limit" field if the given value is not nil. +func (suo *SevUpdateOne) SetNillableLimit(b *bool) *SevUpdateOne { + if b != nil { + suo.SetLimit(*b) + } + return suo +} + +// ClearLimit clears the value of the "limit" field. +func (suo *SevUpdateOne) ClearLimit() *SevUpdateOne { + suo.mutation.ClearLimit() + return suo +} + +// SetCount sets the "count" field. +func (suo *SevUpdateOne) SetCount(i int) *SevUpdateOne { + suo.mutation.ResetCount() + suo.mutation.SetCount(i) + return suo +} + +// SetNillableCount sets the "count" field if the given value is not nil. +func (suo *SevUpdateOne) SetNillableCount(i *int) *SevUpdateOne { + if i != nil { + suo.SetCount(*i) + } + return suo +} + +// AddCount adds i to the "count" field. +func (suo *SevUpdateOne) AddCount(i int) *SevUpdateOne { + suo.mutation.AddCount(i) + return suo +} + +// ClearCount clears the value of the "count" field. +func (suo *SevUpdateOne) ClearCount() *SevUpdateOne { + suo.mutation.ClearCount() + return suo +} + +// SetHandle sets the "handle" field. +func (suo *SevUpdateOne) SetHandle(s string) *SevUpdateOne { + suo.mutation.SetHandle(s) + return suo +} + +// SetNillableHandle sets the "handle" field if the given value is not nil. +func (suo *SevUpdateOne) SetNillableHandle(s *string) *SevUpdateOne { + if s != nil { + suo.SetHandle(*s) + } + return suo +} + +// ClearHandle clears the value of the "handle" field. +func (suo *SevUpdateOne) ClearHandle() *SevUpdateOne { + suo.mutation.ClearHandle() + return suo +} + +// SetDid sets the "did" field. +func (suo *SevUpdateOne) SetDid(s string) *SevUpdateOne { + suo.mutation.SetDid(s) + return suo +} + +// SetNillableDid sets the "did" field if the given value is not nil. +func (suo *SevUpdateOne) SetNillableDid(s *string) *SevUpdateOne { + if s != nil { + suo.SetDid(*s) + } + return suo +} + +// ClearDid clears the value of the "did" field. +func (suo *SevUpdateOne) ClearDid() *SevUpdateOne { + suo.mutation.ClearDid() + return suo +} + +// SetUID sets the "uid" field. +func (suo *SevUpdateOne) SetUID(i int) *SevUpdateOne { + suo.mutation.ResetUID() + suo.mutation.SetUID(i) + return suo +} + +// SetNillableUID sets the "uid" field if the given value is not nil. +func (suo *SevUpdateOne) SetNillableUID(i *int) *SevUpdateOne { + if i != nil { + suo.SetUID(*i) + } + return suo +} + +// AddUID adds i to the "uid" field. +func (suo *SevUpdateOne) AddUID(i int) *SevUpdateOne { + suo.mutation.AddUID(i) + return suo +} + +// ClearUID clears the value of the "uid" field. +func (suo *SevUpdateOne) ClearUID() *SevUpdateOne { + suo.mutation.ClearUID() + return suo +} + +// SetCid sets the "cid" field. +func (suo *SevUpdateOne) SetCid(i int) *SevUpdateOne { + suo.mutation.ResetCid() + suo.mutation.SetCid(i) + return suo +} + +// SetNillableCid sets the "cid" field if the given value is not nil. +func (suo *SevUpdateOne) SetNillableCid(i *int) *SevUpdateOne { + if i != nil { + suo.SetCid(*i) + } + return suo +} + +// AddCid adds i to the "cid" field. +func (suo *SevUpdateOne) AddCid(i int) *SevUpdateOne { + suo.mutation.AddCid(i) + return suo +} + +// ClearCid clears the value of the "cid" field. +func (suo *SevUpdateOne) ClearCid() *SevUpdateOne { + suo.mutation.ClearCid() + return suo +} + +// SetCp sets the "cp" field. +func (suo *SevUpdateOne) SetCp(i int) *SevUpdateOne { + suo.mutation.ResetCp() + suo.mutation.SetCp(i) + return suo +} + +// SetNillableCp sets the "cp" field if the given value is not nil. +func (suo *SevUpdateOne) SetNillableCp(i *int) *SevUpdateOne { + if i != nil { + suo.SetCp(*i) + } + return suo +} + +// AddCp adds i to the "cp" field. +func (suo *SevUpdateOne) AddCp(i int) *SevUpdateOne { + suo.mutation.AddCp(i) + return suo +} + +// ClearCp clears the value of the "cp" field. +func (suo *SevUpdateOne) ClearCp() *SevUpdateOne { + suo.mutation.ClearCp() + return suo +} + +// SetCard sets the "card" field. +func (suo *SevUpdateOne) SetCard(i int) *SevUpdateOne { + suo.mutation.ResetCard() + suo.mutation.SetCard(i) + return suo +} + +// SetNillableCard sets the "card" field if the given value is not nil. +func (suo *SevUpdateOne) SetNillableCard(i *int) *SevUpdateOne { + if i != nil { + suo.SetCard(*i) + } + return suo +} + +// AddCard adds i to the "card" field. +func (suo *SevUpdateOne) AddCard(i int) *SevUpdateOne { + suo.mutation.AddCard(i) + return suo +} + +// ClearCard clears the value of the "card" field. +func (suo *SevUpdateOne) ClearCard() *SevUpdateOne { + suo.mutation.ClearCard() + return suo +} + +// SetUpdatedAt sets the "updated_at" field. +func (suo *SevUpdateOne) SetUpdatedAt(t time.Time) *SevUpdateOne { + suo.mutation.SetUpdatedAt(t) + return suo +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (suo *SevUpdateOne) SetNillableUpdatedAt(t *time.Time) *SevUpdateOne { + if t != nil { + suo.SetUpdatedAt(*t) + } + return suo +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (suo *SevUpdateOne) ClearUpdatedAt() *SevUpdateOne { + suo.mutation.ClearUpdatedAt() + return suo +} + +// SetOwnerID sets the "owner" edge to the User entity by ID. +func (suo *SevUpdateOne) SetOwnerID(id int) *SevUpdateOne { + suo.mutation.SetOwnerID(id) + return suo +} + +// SetOwner sets the "owner" edge to the User entity. +func (suo *SevUpdateOne) SetOwner(u *User) *SevUpdateOne { + return suo.SetOwnerID(u.ID) +} + +// Mutation returns the SevMutation object of the builder. +func (suo *SevUpdateOne) Mutation() *SevMutation { + return suo.mutation +} + +// ClearOwner clears the "owner" edge to the User entity. +func (suo *SevUpdateOne) ClearOwner() *SevUpdateOne { + suo.mutation.ClearOwner() + return suo +} + +// Where appends a list predicates to the SevUpdate builder. +func (suo *SevUpdateOne) Where(ps ...predicate.Sev) *SevUpdateOne { + suo.mutation.Where(ps...) + return suo +} + +// Select allows selecting one or more fields (columns) of the returned entity. +// The default is selecting all fields defined in the entity schema. +func (suo *SevUpdateOne) Select(field string, fields ...string) *SevUpdateOne { + suo.fields = append([]string{field}, fields...) + return suo +} + +// Save executes the query and returns the updated Sev entity. +func (suo *SevUpdateOne) Save(ctx context.Context) (*Sev, error) { + return withHooks[*Sev, SevMutation](ctx, suo.sqlSave, suo.mutation, suo.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (suo *SevUpdateOne) SaveX(ctx context.Context) *Sev { + node, err := suo.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (suo *SevUpdateOne) Exec(ctx context.Context) error { + _, err := suo.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (suo *SevUpdateOne) ExecX(ctx context.Context) { + if err := suo.Exec(ctx); err != nil { + panic(err) + } +} + +// check runs all checks and user-defined validators on the builder. +func (suo *SevUpdateOne) check() error { + if _, ok := suo.mutation.OwnerID(); suo.mutation.OwnerCleared() && !ok { + return errors.New(`ent: clearing a required unique edge "Sev.owner"`) + } + return nil +} + +func (suo *SevUpdateOne) sqlSave(ctx context.Context) (_node *Sev, err error) { + if err := suo.check(); err != nil { + return _node, err + } + _spec := sqlgraph.NewUpdateSpec(sev.Table, sev.Columns, sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt)) + id, ok := suo.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Sev.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := suo.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, sev.FieldID) + for _, f := range fields { + if !sev.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + if f != sev.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := suo.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := suo.mutation.Token(); ok { + _spec.SetField(sev.FieldToken, field.TypeString, value) + } + if suo.mutation.TokenCleared() { + _spec.ClearField(sev.FieldToken, field.TypeString) + } + if value, ok := suo.mutation.Limit(); ok { + _spec.SetField(sev.FieldLimit, field.TypeBool, value) + } + if suo.mutation.LimitCleared() { + _spec.ClearField(sev.FieldLimit, field.TypeBool) + } + if value, ok := suo.mutation.Count(); ok { + _spec.SetField(sev.FieldCount, field.TypeInt, value) + } + if value, ok := suo.mutation.AddedCount(); ok { + _spec.AddField(sev.FieldCount, field.TypeInt, value) + } + if suo.mutation.CountCleared() { + _spec.ClearField(sev.FieldCount, field.TypeInt) + } + if value, ok := suo.mutation.Handle(); ok { + _spec.SetField(sev.FieldHandle, field.TypeString, value) + } + if suo.mutation.HandleCleared() { + _spec.ClearField(sev.FieldHandle, field.TypeString) + } + if value, ok := suo.mutation.Did(); ok { + _spec.SetField(sev.FieldDid, field.TypeString, value) + } + if suo.mutation.DidCleared() { + _spec.ClearField(sev.FieldDid, field.TypeString) + } + if value, ok := suo.mutation.UID(); ok { + _spec.SetField(sev.FieldUID, field.TypeInt, value) + } + if value, ok := suo.mutation.AddedUID(); ok { + _spec.AddField(sev.FieldUID, field.TypeInt, value) + } + if suo.mutation.UIDCleared() { + _spec.ClearField(sev.FieldUID, field.TypeInt) + } + if value, ok := suo.mutation.Cid(); ok { + _spec.SetField(sev.FieldCid, field.TypeInt, value) + } + if value, ok := suo.mutation.AddedCid(); ok { + _spec.AddField(sev.FieldCid, field.TypeInt, value) + } + if suo.mutation.CidCleared() { + _spec.ClearField(sev.FieldCid, field.TypeInt) + } + if value, ok := suo.mutation.Cp(); ok { + _spec.SetField(sev.FieldCp, field.TypeInt, value) + } + if value, ok := suo.mutation.AddedCp(); ok { + _spec.AddField(sev.FieldCp, field.TypeInt, value) + } + if suo.mutation.CpCleared() { + _spec.ClearField(sev.FieldCp, field.TypeInt) + } + if value, ok := suo.mutation.Card(); ok { + _spec.SetField(sev.FieldCard, field.TypeInt, value) + } + if value, ok := suo.mutation.AddedCard(); ok { + _spec.AddField(sev.FieldCard, field.TypeInt, value) + } + if suo.mutation.CardCleared() { + _spec.ClearField(sev.FieldCard, field.TypeInt) + } + if value, ok := suo.mutation.UpdatedAt(); ok { + _spec.SetField(sev.FieldUpdatedAt, field.TypeTime, value) + } + if suo.mutation.UpdatedAtCleared() { + _spec.ClearField(sev.FieldUpdatedAt, field.TypeTime) + } + if suo.mutation.CreatedAtCleared() { + _spec.ClearField(sev.FieldCreatedAt, field.TypeTime) + } + if suo.mutation.OwnerCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: sev.OwnerTable, + Columns: []string{sev.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := suo.mutation.OwnerIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: sev.OwnerTable, + Columns: []string{sev.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + _node = &Sev{config: suo.config} + _spec.Assign = _node.assignValues + _spec.ScanValues = _node.scanValues + if err = sqlgraph.UpdateNode(ctx, suo.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{sev.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + suo.mutation.done = true + return _node, nil +} diff --git a/ent/tx.go b/ent/tx.go index 9c7f793..bf83345 100644 --- a/ent/tx.go +++ b/ent/tx.go @@ -18,6 +18,8 @@ type Tx struct { Group *GroupClient // Ma is the client for interacting with the Ma builders. Ma *MaClient + // Sev is the client for interacting with the Sev builders. + Sev *SevClient // Ue is the client for interacting with the Ue builders. Ue *UeClient // User is the client for interacting with the User builders. @@ -156,6 +158,7 @@ func (tx *Tx) init() { tx.Card = NewCardClient(tx.config) tx.Group = NewGroupClient(tx.config) tx.Ma = NewMaClient(tx.config) + tx.Sev = NewSevClient(tx.config) tx.Ue = NewUeClient(tx.config) tx.User = NewUserClient(tx.config) } diff --git a/ent/user.go b/ent/user.go index e0aeab5..bbf0e2e 100644 --- a/ent/user.go +++ b/ent/user.go @@ -132,9 +132,11 @@ type UserEdges struct { Ue []*Ue `json:"ue,omitempty"` // Ma holds the value of the ma edge. Ma []*Ma `json:"ma,omitempty"` + // Sev holds the value of the sev edge. + Sev []*Sev `json:"sev,omitempty"` // loadedTypes holds the information for reporting if a // type was loaded (or requested) in eager-loading or not. - loadedTypes [3]bool + loadedTypes [4]bool } // CardOrErr returns the Card value or an error if the edge @@ -164,6 +166,15 @@ func (e UserEdges) MaOrErr() ([]*Ma, error) { return nil, &NotLoadedError{edge: "ma"} } +// SevOrErr returns the Sev value or an error if the edge +// was not loaded in eager-loading. +func (e UserEdges) SevOrErr() ([]*Sev, error) { + if e.loadedTypes[3] { + return e.Sev, nil + } + return nil, &NotLoadedError{edge: "sev"} +} + // scanValues returns the types for scanning values from sql.Rows. func (*User) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) @@ -535,6 +546,11 @@ func (u *User) QueryMa() *MaQuery { return NewUserClient(u.config).QueryMa(u) } +// QuerySev queries the "sev" edge of the User entity. +func (u *User) QuerySev() *SevQuery { + return NewUserClient(u.config).QuerySev(u) +} + // Update returns a builder for updating this User. // Note that you need to call User.Unwrap() before calling this method if this User // was returned from a transaction, and the transaction was committed or rolled back. diff --git a/ent/user/user.go b/ent/user/user.go index dbf0881..4a1ce6b 100644 --- a/ent/user/user.go +++ b/ent/user/user.go @@ -120,6 +120,8 @@ const ( EdgeUe = "ue" // EdgeMa holds the string denoting the ma edge name in mutations. EdgeMa = "ma" + // EdgeSev holds the string denoting the sev edge name in mutations. + EdgeSev = "sev" // Table holds the table name of the user in the database. Table = "users" // CardTable is the table that holds the card relation/edge. @@ -143,6 +145,13 @@ const ( MaInverseTable = "mas" // MaColumn is the table column denoting the ma relation/edge. MaColumn = "user_ma" + // SevTable is the table that holds the sev relation/edge. + SevTable = "sevs" + // SevInverseTable is the table name for the Sev entity. + // It exists in this package in order to avoid circular dependency with the "sev" package. + SevInverseTable = "sevs" + // SevColumn is the table column denoting the sev relation/edge. + SevColumn = "user_sev" ) // Columns holds all SQL columns for user fields. @@ -575,6 +584,20 @@ func ByMa(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { sqlgraph.OrderByNeighborTerms(s, newMaStep(), append([]sql.OrderTerm{term}, terms...)...) } } + +// BySevCount orders the results by sev count. +func BySevCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newSevStep(), opts...) + } +} + +// BySev orders the results by sev terms. +func BySev(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newSevStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} func newCardStep() *sqlgraph.Step { return sqlgraph.NewStep( sqlgraph.From(Table, FieldID), @@ -596,3 +619,10 @@ func newMaStep() *sqlgraph.Step { sqlgraph.Edge(sqlgraph.O2M, false, MaTable, MaColumn), ) } +func newSevStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(SevInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, SevTable, SevColumn), + ) +} diff --git a/ent/user/where.go b/ent/user/where.go index 3e3b9d8..0ddcdda 100644 --- a/ent/user/where.go +++ b/ent/user/where.go @@ -2629,6 +2629,29 @@ func HasMaWith(preds ...predicate.Ma) predicate.User { }) } +// HasSev applies the HasEdge predicate on the "sev" edge. +func HasSev() predicate.User { + return predicate.User(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, SevTable, SevColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasSevWith applies the HasEdge predicate on the "sev" edge with a given conditions (other predicates). +func HasSevWith(preds ...predicate.Sev) predicate.User { + return predicate.User(func(s *sql.Selector) { + step := newSevStep() + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.User) predicate.User { return predicate.User(func(s *sql.Selector) { diff --git a/ent/user_create.go b/ent/user_create.go index d8039d7..9cf78c4 100644 --- a/ent/user_create.go +++ b/ent/user_create.go @@ -5,6 +5,7 @@ package ent import ( "api/ent/card" "api/ent/ma" + "api/ent/sev" "api/ent/ue" "api/ent/user" "context" @@ -752,6 +753,21 @@ func (uc *UserCreate) AddMa(m ...*Ma) *UserCreate { return uc.AddMaIDs(ids...) } +// AddSevIDs adds the "sev" edge to the Sev entity by IDs. +func (uc *UserCreate) AddSevIDs(ids ...int) *UserCreate { + uc.mutation.AddSevIDs(ids...) + return uc +} + +// AddSev adds the "sev" edges to the Sev entity. +func (uc *UserCreate) AddSev(s ...*Sev) *UserCreate { + ids := make([]int, len(s)) + for i := range s { + ids[i] = s[i].ID + } + return uc.AddSevIDs(ids...) +} + // Mutation returns the UserMutation object of the builder. func (uc *UserCreate) Mutation() *UserMutation { return uc.mutation @@ -1177,6 +1193,22 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { } _spec.Edges = append(_spec.Edges, edge) } + if nodes := uc.mutation.SevIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.SevTable, + Columns: []string{user.SevColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } return _node, _spec } diff --git a/ent/user_query.go b/ent/user_query.go index 77b01de..8a667bb 100644 --- a/ent/user_query.go +++ b/ent/user_query.go @@ -6,6 +6,7 @@ import ( "api/ent/card" "api/ent/ma" "api/ent/predicate" + "api/ent/sev" "api/ent/ue" "api/ent/user" "context" @@ -28,6 +29,7 @@ type UserQuery struct { withCard *CardQuery withUe *UeQuery withMa *MaQuery + withSev *SevQuery withFKs bool // intermediate query (i.e. traversal path). sql *sql.Selector @@ -131,6 +133,28 @@ func (uq *UserQuery) QueryMa() *MaQuery { return query } +// QuerySev chains the current query on the "sev" edge. +func (uq *UserQuery) QuerySev() *SevQuery { + query := (&SevClient{config: uq.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := uq.prepareQuery(ctx); err != nil { + return nil, err + } + selector := uq.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(user.Table, user.FieldID, selector), + sqlgraph.To(sev.Table, sev.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, user.SevTable, user.SevColumn), + ) + fromU = sqlgraph.SetNeighbors(uq.driver.Dialect(), step) + return fromU, nil + } + return query +} + // First returns the first User entity from the query. // Returns a *NotFoundError when no User was found. func (uq *UserQuery) First(ctx context.Context) (*User, error) { @@ -326,6 +350,7 @@ func (uq *UserQuery) Clone() *UserQuery { withCard: uq.withCard.Clone(), withUe: uq.withUe.Clone(), withMa: uq.withMa.Clone(), + withSev: uq.withSev.Clone(), // clone intermediate query. sql: uq.sql.Clone(), path: uq.path, @@ -365,6 +390,17 @@ func (uq *UserQuery) WithMa(opts ...func(*MaQuery)) *UserQuery { return uq } +// WithSev tells the query-builder to eager-load the nodes that are connected to +// the "sev" edge. The optional arguments are used to configure the query builder of the edge. +func (uq *UserQuery) WithSev(opts ...func(*SevQuery)) *UserQuery { + query := (&SevClient{config: uq.config}).Query() + for _, opt := range opts { + opt(query) + } + uq.withSev = query + return uq +} + // GroupBy is used to group vertices by one or more fields/columns. // It is often used with aggregate functions, like: count, max, mean, min, sum. // @@ -444,10 +480,11 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e nodes = []*User{} withFKs = uq.withFKs _spec = uq.querySpec() - loadedTypes = [3]bool{ + loadedTypes = [4]bool{ uq.withCard != nil, uq.withUe != nil, uq.withMa != nil, + uq.withSev != nil, } ) if withFKs { @@ -492,6 +529,13 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e return nil, err } } + if query := uq.withSev; query != nil { + if err := uq.loadSev(ctx, query, nodes, + func(n *User) { n.Edges.Sev = []*Sev{} }, + func(n *User, e *Sev) { n.Edges.Sev = append(n.Edges.Sev, e) }); err != nil { + return nil, err + } + } return nodes, nil } @@ -588,6 +632,37 @@ func (uq *UserQuery) loadMa(ctx context.Context, query *MaQuery, nodes []*User, } return nil } +func (uq *UserQuery) loadSev(ctx context.Context, query *SevQuery, nodes []*User, init func(*User), assign func(*User, *Sev)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[int]*User) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + query.withFKs = true + query.Where(predicate.Sev(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(user.SevColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.user_sev + if fk == nil { + return fmt.Errorf(`foreign-key "user_sev" is nil for node %v`, n.ID) + } + node, ok := nodeids[*fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "user_sev" returned %v for node %v`, *fk, n.ID) + } + assign(node, n) + } + return nil +} func (uq *UserQuery) sqlCount(ctx context.Context) (int, error) { _spec := uq.querySpec() diff --git a/ent/user_update.go b/ent/user_update.go index ed074ba..8d8ef0f 100644 --- a/ent/user_update.go +++ b/ent/user_update.go @@ -6,6 +6,7 @@ import ( "api/ent/card" "api/ent/ma" "api/ent/predicate" + "api/ent/sev" "api/ent/ue" "api/ent/user" "context" @@ -1128,6 +1129,21 @@ func (uu *UserUpdate) AddMa(m ...*Ma) *UserUpdate { return uu.AddMaIDs(ids...) } +// AddSevIDs adds the "sev" edge to the Sev entity by IDs. +func (uu *UserUpdate) AddSevIDs(ids ...int) *UserUpdate { + uu.mutation.AddSevIDs(ids...) + return uu +} + +// AddSev adds the "sev" edges to the Sev entity. +func (uu *UserUpdate) AddSev(s ...*Sev) *UserUpdate { + ids := make([]int, len(s)) + for i := range s { + ids[i] = s[i].ID + } + return uu.AddSevIDs(ids...) +} + // Mutation returns the UserMutation object of the builder. func (uu *UserUpdate) Mutation() *UserMutation { return uu.mutation @@ -1196,6 +1212,27 @@ func (uu *UserUpdate) RemoveMa(m ...*Ma) *UserUpdate { return uu.RemoveMaIDs(ids...) } +// ClearSev clears all "sev" edges to the Sev entity. +func (uu *UserUpdate) ClearSev() *UserUpdate { + uu.mutation.ClearSev() + return uu +} + +// RemoveSevIDs removes the "sev" edge to Sev entities by IDs. +func (uu *UserUpdate) RemoveSevIDs(ids ...int) *UserUpdate { + uu.mutation.RemoveSevIDs(ids...) + return uu +} + +// RemoveSev removes "sev" edges to Sev entities. +func (uu *UserUpdate) RemoveSev(s ...*Sev) *UserUpdate { + ids := make([]int, len(s)) + for i := range s { + ids[i] = s[i].ID + } + return uu.RemoveSevIDs(ids...) +} + // Save executes the query and returns the number of nodes affected by the update operation. func (uu *UserUpdate) Save(ctx context.Context) (int, error) { return withHooks[int, UserMutation](ctx, uu.sqlSave, uu.mutation, uu.hooks) @@ -1700,6 +1737,51 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if uu.mutation.SevCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.SevTable, + Columns: []string{user.SevColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := uu.mutation.RemovedSevIDs(); len(nodes) > 0 && !uu.mutation.SevCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.SevTable, + Columns: []string{user.SevColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := uu.mutation.SevIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.SevTable, + Columns: []string{user.SevColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{user.Label} @@ -2817,6 +2899,21 @@ func (uuo *UserUpdateOne) AddMa(m ...*Ma) *UserUpdateOne { return uuo.AddMaIDs(ids...) } +// AddSevIDs adds the "sev" edge to the Sev entity by IDs. +func (uuo *UserUpdateOne) AddSevIDs(ids ...int) *UserUpdateOne { + uuo.mutation.AddSevIDs(ids...) + return uuo +} + +// AddSev adds the "sev" edges to the Sev entity. +func (uuo *UserUpdateOne) AddSev(s ...*Sev) *UserUpdateOne { + ids := make([]int, len(s)) + for i := range s { + ids[i] = s[i].ID + } + return uuo.AddSevIDs(ids...) +} + // Mutation returns the UserMutation object of the builder. func (uuo *UserUpdateOne) Mutation() *UserMutation { return uuo.mutation @@ -2885,6 +2982,27 @@ func (uuo *UserUpdateOne) RemoveMa(m ...*Ma) *UserUpdateOne { return uuo.RemoveMaIDs(ids...) } +// ClearSev clears all "sev" edges to the Sev entity. +func (uuo *UserUpdateOne) ClearSev() *UserUpdateOne { + uuo.mutation.ClearSev() + return uuo +} + +// RemoveSevIDs removes the "sev" edge to Sev entities by IDs. +func (uuo *UserUpdateOne) RemoveSevIDs(ids ...int) *UserUpdateOne { + uuo.mutation.RemoveSevIDs(ids...) + return uuo +} + +// RemoveSev removes "sev" edges to Sev entities. +func (uuo *UserUpdateOne) RemoveSev(s ...*Sev) *UserUpdateOne { + ids := make([]int, len(s)) + for i := range s { + ids[i] = s[i].ID + } + return uuo.RemoveSevIDs(ids...) +} + // Where appends a list predicates to the UserUpdate builder. func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne { uuo.mutation.Where(ps...) @@ -3419,6 +3537,51 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if uuo.mutation.SevCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.SevTable, + Columns: []string{user.SevColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt), + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := uuo.mutation.RemovedSevIDs(); len(nodes) > 0 && !uuo.mutation.SevCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.SevTable, + Columns: []string{user.SevColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := uuo.mutation.SevIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.SevTable, + Columns: []string{user.SevColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt), + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } _node = &User{config: uuo.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues diff --git a/tmp/ogent/oas_response_encoders_gen.go b/tmp/ogent/oas_response_encoders_gen.go index 8432973..5ce3edb 100644 --- a/tmp/ogent/oas_response_encoders_gen.go +++ b/tmp/ogent/oas_response_encoders_gen.go @@ -176,6 +176,61 @@ func encodeCreateMaResponse(response CreateMaRes, w http.ResponseWriter, span tr } } +func encodeCreateSevResponse(response CreateSevRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *SevCreate: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeCreateUeResponse(response CreateUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *UeCreate: @@ -469,6 +524,67 @@ func encodeDeleteMaResponse(response DeleteMaRes, w http.ResponseWriter, span tr } } +func encodeDeleteSevResponse(response DeleteSevRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *DeleteSevNoContent: + w.WriteHeader(204) + span.SetStatus(codes.Ok, http.StatusText(204)) + + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeDeleteUeResponse(response DeleteUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *DeleteUeNoContent: @@ -875,6 +991,74 @@ func encodeListMaResponse(response ListMaRes, w http.ResponseWriter, span trace. } } +func encodeListSevResponse(response ListSevRes, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai") + switch response := response.(type) { + case *ListSevOKApplicationJSON: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeListUeResponse(response ListUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *ListUeOKApplicationJSON: @@ -1146,6 +1330,73 @@ func encodeListUserMaResponse(response ListUserMaRes, w http.ResponseWriter, spa } } +func encodeListUserSevResponse(response ListUserSevRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *ListUserSevOKApplicationJSON: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeListUserUeResponse(response ListUserUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *ListUserUeOKApplicationJSON: @@ -1485,6 +1736,7 @@ func encodeReadMaResponse(response ReadMaRes, w http.ResponseWriter, span trace. } func encodeReadMaOwnerResponse(response ReadMaOwnerRes, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Access-Control-Allow-Origin", "https://manga.syui.ai") switch response := response.(type) { case *MaOwnerRead: w.Header().Set("Content-Type", "application/json") @@ -1551,6 +1803,142 @@ func encodeReadMaOwnerResponse(response ReadMaOwnerRes, w http.ResponseWriter, s } } +func encodeReadSevResponse(response ReadSevRes, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai") + switch response := response.(type) { + case *SevRead: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + +func encodeReadSevOwnerResponse(response ReadSevOwnerRes, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai") + switch response := response.(type) { + case *SevOwnerRead: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeReadUeResponse(response ReadUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *UeRead: @@ -1686,6 +2074,7 @@ func encodeReadUeOwnerResponse(response ReadUeOwnerRes, w http.ResponseWriter, s } func encodeReadUserResponse(response ReadUserRes, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai") switch response := response.(type) { case *UserRead: w.Header().Set("Content-Type", "application/json") @@ -1953,6 +2342,73 @@ func encodeUpdateMaResponse(response UpdateMaRes, w http.ResponseWriter, span tr } } +func encodeUpdateSevResponse(response UpdateSevRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *SevUpdate: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R400: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(400) + span.SetStatus(codes.Error, http.StatusText(400)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R404: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(404) + span.SetStatus(codes.Error, http.StatusText(404)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R409: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(409) + span.SetStatus(codes.Error, http.StatusText(409)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + case *R500: + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(500) + span.SetStatus(codes.Error, http.StatusText(500)) + + e := jx.GetEncoder() + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeUpdateUeResponse(response UpdateUeRes, w http.ResponseWriter, span trace.Span) error { switch response := response.(type) { case *UeUpdate: diff --git a/tmp/ogent/ogent.go b/tmp/ogent/ogent.go index da38617..567addf 100644 --- a/tmp/ogent/ogent.go +++ b/tmp/ogent/ogent.go @@ -11,6 +11,7 @@ import ( "api/ent/group" "api/ent/ma" "api/ent/ue" + "api/ent/sev" "api/ent/user" "os" @@ -781,6 +782,276 @@ func (h *OgentHandler) ReadMaOwner(ctx context.Context, params ReadMaOwnerParams return NewMaOwnerRead(e), nil } +// CreateSev handles POST /sevs requests. +func (h *OgentHandler) CreateSev(ctx context.Context, req *CreateSevReq) (CreateSevRes, error) { + b := h.client.Sev.Create() + // Add all fields. + b.SetPassword(req.Password) + if v, ok := req.Token.Get(); ok { + b.SetToken(v) + } + if v, ok := req.Limit.Get(); ok { + b.SetLimit(v) + } + if v, ok := req.Count.Get(); ok { + b.SetCount(v) + } + if v, ok := req.Handle.Get(); ok { + b.SetHandle(v) + } + if v, ok := req.Did.Get(); ok { + b.SetDid(v) + } + if v, ok := req.UID.Get(); ok { + b.SetUID(v) + } + if v, ok := req.Cid.Get(); ok { + b.SetCid(v) + } + if v, ok := req.Card.Get(); ok { + b.SetCard(v) + } + if v, ok := req.Cp.Get(); ok { + b.SetCp(v) + } + if v, ok := req.UpdatedAt.Get(); ok { + b.SetUpdatedAt(v) + } + if v, ok := req.CreatedAt.Get(); ok { + b.SetCreatedAt(v) + } + + // Add all edges. + //b.SetOwnerID(req.Owner) + if req.Password == password { + b.SetOwnerID(req.Owner) + } else { + b.SetOwnerID(0) + } + // Persist to storage. + e, err := b.Save(ctx) + if err != nil { + switch { + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + // Reload the entity to attach all eager-loaded edges. + q := h.client.Sev.Query().Where(sev.ID(e.ID)) + e, err = q.Only(ctx) + if err != nil { + // This should never happen. + return nil, err + } + return NewSevCreate(e), nil +} + +// ReadSev handles GET /sevs/{id} requests. +func (h *OgentHandler) ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error) { + q := h.client.Sev.Query().Where(sev.IDEQ(params.ID)) + e, err := q.Only(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + return NewSevRead(e), nil +} + +// UpdateSev handles PATCH /sevs/{id} requests. +func (h *OgentHandler) UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error) { + b := h.client.Sev.UpdateOneID(params.ID) + // Add all fields. + if v, ok := req.Token.Get(); ok { + b.SetToken(v) + } + if v, ok := req.Limit.Get(); ok { + b.SetLimit(v) + } + if v, ok := req.Count.Get(); ok { + b.SetCount(v) + } + if v, ok := req.Handle.Get(); ok { + b.SetHandle(v) + } + if v, ok := req.Did.Get(); ok { + b.SetDid(v) + } + if v, ok := req.UID.Get(); ok { + b.SetUID(v) + } + if v, ok := req.Cid.Get(); ok { + b.SetCid(v) + } + if v, ok := req.Card.Get(); ok { + b.SetCard(v) + } + if v, ok := req.Cp.Get(); ok { + b.SetCp(v) + } + if v, ok := req.UpdatedAt.Get(); ok { + b.SetUpdatedAt(v) + } + // Add all edges. + //if v, ok := req.Owner.Get(); ok { + // b.SetOwnerID(v) + //} + if v, ok := req.Token.Get(); ok { + if v == token { + b.SetToken(v) + if v, ok := req.Owner.Get(); ok { + b.SetOwnerID(v) + } + } + } + // Persist to storage. + e, err := b.Save(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + // Reload the entity to attach all eager-loaded edges. + q := h.client.Sev.Query().Where(sev.ID(e.ID)) + e, err = q.Only(ctx) + if err != nil { + // This should never happen. + return nil, err + } + return NewSevUpdate(e), nil +} + +// DeleteSev handles DELETE /sevs/{id} requests. +func (h *OgentHandler) DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error) { + //err := h.client.Sev.DeleteOneID(params.ID).Exec(ctx) + err := h.client.Sev.DeleteOneID(0).Exec(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + return new(DeleteSevNoContent), nil + +} + +// ListSev handles GET /sevs requests. +func (h *OgentHandler) ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error) { + q := h.client.Sev.Query() + page := 1 + if v, ok := params.Page.Get(); ok { + page = v + } + itemsPerPage := 30 + if v, ok := params.ItemsPerPage.Get(); ok { + itemsPerPage = v + } + q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage) + + es, err := q.All(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + r := NewSevLists(es) + return (*ListSevOKApplicationJSON)(&r), nil +} + +// ReadSevOwner handles GET /sevs/{id}/owner requests. +func (h *OgentHandler) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error) { + q := h.client.Sev.Query().Where(sev.IDEQ(params.ID)).QueryOwner() + e, err := q.Only(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + return NewSevOwnerRead(e), nil +} + // CreateUe handles POST /ues requests. func (h *OgentHandler) CreateUe(ctx context.Context, req *CreateUeReq) (CreateUeRes, error) { b := h.client.Ue.Create() @@ -1671,3 +1942,39 @@ func (h *OgentHandler) ListUserMa(ctx context.Context, params ListUserMaParams) r := NewUserMaLists(es) return (*ListUserMaOKApplicationJSON)(&r), nil } + +// ListUserSev handles GET /users/{id}/sev requests. +func (h *OgentHandler) ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error) { + q := h.client.User.Query().Where(user.IDEQ(params.ID)).QuerySev() + page := 1 + if v, ok := params.Page.Get(); ok { + page = v + } + itemsPerPage := 30 + if v, ok := params.ItemsPerPage.Get(); ok { + itemsPerPage = v + } + q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage) + es, err := q.All(ctx) + if err != nil { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + r := NewUserSevLists(es) + return (*ListUserSevOKApplicationJSON)(&r), nil +}