From 22734a4b4cd9b576819fd13f2820e4f8bbcb58d7 Mon Sep 17 00:00:00 2001 From: syui Date: Wed, 31 Aug 2022 16:49:08 +0900 Subject: [PATCH] first gen --- ent/card.go | 181 + ent/card/card.go | 79 + ent/card/where.go | 440 +++ ent/card_create.go | 318 ++ ent/card_delete.go | 88 + ent/card_query.go | 613 ++++ ent/card_update.go | 332 ++ ent/client.go | 581 +++- ent/config.go | 59 - ent/context.go | 33 - ent/ent.go | 385 ++- ent/entc.go | 11 +- ent/enttest/enttest.go | 23 +- ent/generate.go | 1 - ent/group.go | 119 + ent/group/group.go | 39 + ent/group/where.go | 184 + ent/group_create.go | 214 ++ ent/group_delete.go | 88 + ent/group_query.go | 606 ++++ ent/group_update.go | 374 ++ ent/hook/hook.go | 45 +- ent/http/create.go | 224 -- ent/http/delete.go | 116 - ent/http/easyjson.go | 1075 ------ ent/http/handler.go | 185 - ent/http/list.go | 147 - ent/http/read.go | 149 - ent/http/relations.go | 3 - ent/http/request.go | 42 - ent/http/response.go | 200 -- ent/http/update.go | 260 -- ent/migrate/migrate.go | 27 +- ent/migrate/schema.go | 82 +- ent/mutation.go | 2897 ++++++++-------- ent/ogent/oas_cfg_gen.go | 304 +- ent/ogent/oas_client_gen.go | 1731 ++++++++-- ent/ogent/oas_defaults_gen.go | 71 - ent/ogent/oas_handlers_gen.go | 2199 ++++++++++-- ent/ogent/oas_interfaces_gen.go | 72 +- ent/ogent/oas_json_gen.go | 4404 +++++++++++++++--------- ent/ogent/oas_middleware_gen.go | 10 + ent/ogent/oas_param_dec_gen.go | 339 -- ent/ogent/oas_param_gen.go | 101 - ent/ogent/oas_parameters_gen.go | 1587 +++++++++ ent/ogent/oas_req_dec_gen.go | 159 - ent/ogent/oas_req_enc_gen.go | 87 - ent/ogent/oas_request_decoders_gen.go | 394 +++ ent/ogent/oas_request_encoders_gen.go | 96 + ent/ogent/oas_res_dec_gen.go | 747 ---- ent/ogent/oas_res_enc_gen.go | 395 --- ent/ogent/oas_response_decoders_gen.go | 3090 +++++++++++++++++ ent/ogent/oas_response_encoders_gen.go | 1178 +++++++ ent/ogent/oas_router_gen.go | 1008 ++++-- ent/ogent/oas_schemas_gen.go | 1567 +++++++-- ent/ogent/oas_security_gen.go | 71 - ent/ogent/oas_server_gen.go | 212 +- ent/ogent/oas_unimplemented_gen.go | 229 +- ent/ogent/oas_validators_gen.go | 244 +- ent/ogent/ogent.go | 594 +++- ent/ogent/responses.go | 510 ++- ent/openapi.json | 1814 +++++++--- ent/predicate/predicate.go | 12 +- ent/runtime.go | 126 +- ent/runtime/runtime.go | 6 +- ent/schema/card.go | 97 + ent/schema/group.go | 35 + ent/schema/user.go | 74 + ent/schema/users.go | 172 - ent/tx.go | 56 +- ent/user.go | 165 + ent/user/user.go | 74 + ent/user/where.go | 375 ++ ent/user_create.go | 292 ++ ent/user_delete.go | 88 + ent/user_query.go | 611 ++++ ent/user_update.go | 467 +++ ent/users.go | 276 -- ent/users/users.go | 124 - ent/users/where.go | 2005 ----------- ent/users_create.go | 674 ---- ent/users_delete.go | 111 - ent/users_query.go | 920 ----- ent/users_update.go | 1316 ------- fly.toml | 29 - go.mod | 85 +- go.sum | 1014 +----- main.go | 132 +- readme.md | 65 +- 89 files changed, 25861 insertions(+), 16973 deletions(-) create mode 100644 ent/card.go create mode 100644 ent/card/card.go create mode 100644 ent/card/where.go create mode 100644 ent/card_create.go create mode 100644 ent/card_delete.go create mode 100644 ent/card_query.go create mode 100644 ent/card_update.go delete mode 100644 ent/config.go delete mode 100644 ent/context.go create mode 100644 ent/group.go create mode 100644 ent/group/group.go create mode 100644 ent/group/where.go create mode 100644 ent/group_create.go create mode 100644 ent/group_delete.go create mode 100644 ent/group_query.go create mode 100644 ent/group_update.go delete mode 100644 ent/http/create.go delete mode 100644 ent/http/delete.go delete mode 100644 ent/http/easyjson.go delete mode 100644 ent/http/handler.go delete mode 100644 ent/http/list.go delete mode 100644 ent/http/read.go delete mode 100644 ent/http/relations.go delete mode 100644 ent/http/request.go delete mode 100644 ent/http/response.go delete mode 100644 ent/http/update.go delete mode 100644 ent/ogent/oas_defaults_gen.go create mode 100644 ent/ogent/oas_middleware_gen.go delete mode 100644 ent/ogent/oas_param_dec_gen.go delete mode 100644 ent/ogent/oas_param_gen.go create mode 100644 ent/ogent/oas_parameters_gen.go delete mode 100644 ent/ogent/oas_req_dec_gen.go delete mode 100644 ent/ogent/oas_req_enc_gen.go create mode 100644 ent/ogent/oas_request_decoders_gen.go create mode 100644 ent/ogent/oas_request_encoders_gen.go delete mode 100644 ent/ogent/oas_res_dec_gen.go delete mode 100644 ent/ogent/oas_res_enc_gen.go create mode 100644 ent/ogent/oas_response_decoders_gen.go create mode 100644 ent/ogent/oas_response_encoders_gen.go delete mode 100644 ent/ogent/oas_security_gen.go create mode 100644 ent/schema/card.go create mode 100644 ent/schema/group.go create mode 100644 ent/schema/user.go delete mode 100644 ent/schema/users.go create mode 100644 ent/user.go create mode 100644 ent/user/user.go create mode 100644 ent/user/where.go create mode 100644 ent/user_create.go create mode 100644 ent/user_delete.go create mode 100644 ent/user_query.go create mode 100644 ent/user_update.go delete mode 100644 ent/users.go delete mode 100644 ent/users/users.go delete mode 100644 ent/users/where.go delete mode 100644 ent/users_create.go delete mode 100644 ent/users_delete.go delete mode 100644 ent/users_query.go delete mode 100644 ent/users_update.go delete mode 100644 fly.toml diff --git a/ent/card.go b/ent/card.go new file mode 100644 index 0000000..2cd10fd --- /dev/null +++ b/ent/card.go @@ -0,0 +1,181 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "fmt" + "strings" + "t/ent/card" + "t/ent/user" + "time" + + "entgo.io/ent/dialect/sql" +) + +// Card is the model entity for the Card schema. +type Card struct { + config `json:"-"` + // ID of the ent. + ID int `json:"id,omitempty"` + // Card holds the value of the "card" field. + Card int `json:"card,omitempty"` + // Status holds the value of the "status" field. + Status string `json:"status,omitempty"` + // Cp holds the value of the "cp" field. + Cp int `json:"cp,omitempty"` + // URL holds the value of the "url" field. + URL string `json:"url,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 CardQuery when eager-loading is set. + Edges CardEdges `json:"edges"` + user_card *int +} + +// CardEdges holds the relations/edges for other nodes in the graph. +type CardEdges 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 CardEdges) 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 (*Card) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case card.FieldID, card.FieldCard, card.FieldCp: + values[i] = new(sql.NullInt64) + case card.FieldStatus, card.FieldURL: + values[i] = new(sql.NullString) + case card.FieldCreatedAt: + values[i] = new(sql.NullTime) + case card.ForeignKeys[0]: // user_card + values[i] = new(sql.NullInt64) + default: + return nil, fmt.Errorf("unexpected column %q for type Card", columns[i]) + } + } + return values, nil +} + +// assignValues assigns the values that were returned from sql.Rows (after scanning) +// to the Card fields. +func (c *Card) 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 card.FieldID: + value, ok := values[i].(*sql.NullInt64) + if !ok { + return fmt.Errorf("unexpected type %T for field id", value) + } + c.ID = int(value.Int64) + case card.FieldCard: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field card", values[i]) + } else if value.Valid { + c.Card = int(value.Int64) + } + case card.FieldStatus: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field status", values[i]) + } else if value.Valid { + c.Status = value.String + } + case card.FieldCp: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field cp", values[i]) + } else if value.Valid { + c.Cp = int(value.Int64) + } + case card.FieldURL: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field url", values[i]) + } else if value.Valid { + c.URL = value.String + } + case card.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 { + c.CreatedAt = value.Time + } + case card.ForeignKeys[0]: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for edge-field user_card", value) + } else if value.Valid { + c.user_card = new(int) + *c.user_card = int(value.Int64) + } + } + } + return nil +} + +// QueryOwner queries the "owner" edge of the Card entity. +func (c *Card) QueryOwner() *UserQuery { + return NewCardClient(c.config).QueryOwner(c) +} + +// Update returns a builder for updating this Card. +// Note that you need to call Card.Unwrap() before calling this method if this Card +// was returned from a transaction, and the transaction was committed or rolled back. +func (c *Card) Update() *CardUpdateOne { + return NewCardClient(c.config).UpdateOne(c) +} + +// Unwrap unwraps the Card 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 (c *Card) Unwrap() *Card { + _tx, ok := c.config.driver.(*txDriver) + if !ok { + panic("ent: Card is not a transactional entity") + } + c.config.driver = _tx.drv + return c +} + +// String implements the fmt.Stringer. +func (c *Card) String() string { + var builder strings.Builder + builder.WriteString("Card(") + builder.WriteString(fmt.Sprintf("id=%v, ", c.ID)) + builder.WriteString("card=") + builder.WriteString(fmt.Sprintf("%v", c.Card)) + builder.WriteString(", ") + builder.WriteString("status=") + builder.WriteString(c.Status) + builder.WriteString(", ") + builder.WriteString("cp=") + builder.WriteString(fmt.Sprintf("%v", c.Cp)) + builder.WriteString(", ") + builder.WriteString("url=") + builder.WriteString(c.URL) + builder.WriteString(", ") + builder.WriteString("created_at=") + builder.WriteString(c.CreatedAt.Format(time.ANSIC)) + builder.WriteByte(')') + return builder.String() +} + +// Cards is a parsable slice of Card. +type Cards []*Card diff --git a/ent/card/card.go b/ent/card/card.go new file mode 100644 index 0000000..dc7ec21 --- /dev/null +++ b/ent/card/card.go @@ -0,0 +1,79 @@ +// Code generated by ent, DO NOT EDIT. + +package card + +import ( + "time" +) + +const ( + // Label holds the string label denoting the card type in the database. + Label = "card" + // FieldID holds the string denoting the id field in the database. + FieldID = "id" + // FieldCard holds the string denoting the card field in the database. + FieldCard = "card" + // FieldStatus holds the string denoting the status field in the database. + FieldStatus = "status" + // FieldCp holds the string denoting the cp field in the database. + FieldCp = "cp" + // FieldURL holds the string denoting the url field in the database. + FieldURL = "url" + // 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 card in the database. + Table = "cards" + // OwnerTable is the table that holds the owner relation/edge. + OwnerTable = "cards" + // 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_card" +) + +// Columns holds all SQL columns for card fields. +var Columns = []string{ + FieldID, + FieldCard, + FieldStatus, + FieldCp, + FieldURL, + FieldCreatedAt, +} + +// ForeignKeys holds the SQL foreign-keys that are owned by the "cards" +// table and are not defined as standalone fields in the schema. +var ForeignKeys = []string{ + "user_card", +} + +// 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 ( + // DefaultCard holds the default value on creation for the "card" field. + DefaultCard func() int + // DefaultStatus holds the default value on creation for the "status" field. + DefaultStatus func() string + // DefaultCp holds the default value on creation for the "cp" field. + DefaultCp func() int + // DefaultURL holds the default value on creation for the "url" field. + DefaultURL string + // DefaultCreatedAt holds the default value on creation for the "created_at" field. + DefaultCreatedAt func() time.Time +) diff --git a/ent/card/where.go b/ent/card/where.go new file mode 100644 index 0000000..04dfae6 --- /dev/null +++ b/ent/card/where.go @@ -0,0 +1,440 @@ +// Code generated by ent, DO NOT EDIT. + +package card + +import ( + "t/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.Card { + return predicate.Card(sql.FieldEQ(FieldID, id)) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id int) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldID, id)) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id int) predicate.Card { + return predicate.Card(sql.FieldNEQ(FieldID, id)) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...int) predicate.Card { + return predicate.Card(sql.FieldIn(FieldID, ids...)) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...int) predicate.Card { + return predicate.Card(sql.FieldNotIn(FieldID, ids...)) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id int) predicate.Card { + return predicate.Card(sql.FieldGT(FieldID, id)) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id int) predicate.Card { + return predicate.Card(sql.FieldGTE(FieldID, id)) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id int) predicate.Card { + return predicate.Card(sql.FieldLT(FieldID, id)) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id int) predicate.Card { + return predicate.Card(sql.FieldLTE(FieldID, id)) +} + +// Card applies equality check predicate on the "card" field. It's identical to CardEQ. +func Card(v int) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldCard, v)) +} + +// Status applies equality check predicate on the "status" field. It's identical to StatusEQ. +func Status(v string) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldStatus, v)) +} + +// Cp applies equality check predicate on the "cp" field. It's identical to CpEQ. +func Cp(v int) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldCp, v)) +} + +// URL applies equality check predicate on the "url" field. It's identical to URLEQ. +func URL(v string) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldURL, v)) +} + +// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ. +func CreatedAt(v time.Time) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldCreatedAt, v)) +} + +// CardEQ applies the EQ predicate on the "card" field. +func CardEQ(v int) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldCard, v)) +} + +// CardNEQ applies the NEQ predicate on the "card" field. +func CardNEQ(v int) predicate.Card { + return predicate.Card(sql.FieldNEQ(FieldCard, v)) +} + +// CardIn applies the In predicate on the "card" field. +func CardIn(vs ...int) predicate.Card { + return predicate.Card(sql.FieldIn(FieldCard, vs...)) +} + +// CardNotIn applies the NotIn predicate on the "card" field. +func CardNotIn(vs ...int) predicate.Card { + return predicate.Card(sql.FieldNotIn(FieldCard, vs...)) +} + +// CardGT applies the GT predicate on the "card" field. +func CardGT(v int) predicate.Card { + return predicate.Card(sql.FieldGT(FieldCard, v)) +} + +// CardGTE applies the GTE predicate on the "card" field. +func CardGTE(v int) predicate.Card { + return predicate.Card(sql.FieldGTE(FieldCard, v)) +} + +// CardLT applies the LT predicate on the "card" field. +func CardLT(v int) predicate.Card { + return predicate.Card(sql.FieldLT(FieldCard, v)) +} + +// CardLTE applies the LTE predicate on the "card" field. +func CardLTE(v int) predicate.Card { + return predicate.Card(sql.FieldLTE(FieldCard, v)) +} + +// CardIsNil applies the IsNil predicate on the "card" field. +func CardIsNil() predicate.Card { + return predicate.Card(sql.FieldIsNull(FieldCard)) +} + +// CardNotNil applies the NotNil predicate on the "card" field. +func CardNotNil() predicate.Card { + return predicate.Card(sql.FieldNotNull(FieldCard)) +} + +// StatusEQ applies the EQ predicate on the "status" field. +func StatusEQ(v string) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldStatus, v)) +} + +// StatusNEQ applies the NEQ predicate on the "status" field. +func StatusNEQ(v string) predicate.Card { + return predicate.Card(sql.FieldNEQ(FieldStatus, v)) +} + +// StatusIn applies the In predicate on the "status" field. +func StatusIn(vs ...string) predicate.Card { + return predicate.Card(sql.FieldIn(FieldStatus, vs...)) +} + +// StatusNotIn applies the NotIn predicate on the "status" field. +func StatusNotIn(vs ...string) predicate.Card { + return predicate.Card(sql.FieldNotIn(FieldStatus, vs...)) +} + +// StatusGT applies the GT predicate on the "status" field. +func StatusGT(v string) predicate.Card { + return predicate.Card(sql.FieldGT(FieldStatus, v)) +} + +// StatusGTE applies the GTE predicate on the "status" field. +func StatusGTE(v string) predicate.Card { + return predicate.Card(sql.FieldGTE(FieldStatus, v)) +} + +// StatusLT applies the LT predicate on the "status" field. +func StatusLT(v string) predicate.Card { + return predicate.Card(sql.FieldLT(FieldStatus, v)) +} + +// StatusLTE applies the LTE predicate on the "status" field. +func StatusLTE(v string) predicate.Card { + return predicate.Card(sql.FieldLTE(FieldStatus, v)) +} + +// StatusContains applies the Contains predicate on the "status" field. +func StatusContains(v string) predicate.Card { + return predicate.Card(sql.FieldContains(FieldStatus, v)) +} + +// StatusHasPrefix applies the HasPrefix predicate on the "status" field. +func StatusHasPrefix(v string) predicate.Card { + return predicate.Card(sql.FieldHasPrefix(FieldStatus, v)) +} + +// StatusHasSuffix applies the HasSuffix predicate on the "status" field. +func StatusHasSuffix(v string) predicate.Card { + return predicate.Card(sql.FieldHasSuffix(FieldStatus, v)) +} + +// StatusIsNil applies the IsNil predicate on the "status" field. +func StatusIsNil() predicate.Card { + return predicate.Card(sql.FieldIsNull(FieldStatus)) +} + +// StatusNotNil applies the NotNil predicate on the "status" field. +func StatusNotNil() predicate.Card { + return predicate.Card(sql.FieldNotNull(FieldStatus)) +} + +// StatusEqualFold applies the EqualFold predicate on the "status" field. +func StatusEqualFold(v string) predicate.Card { + return predicate.Card(sql.FieldEqualFold(FieldStatus, v)) +} + +// StatusContainsFold applies the ContainsFold predicate on the "status" field. +func StatusContainsFold(v string) predicate.Card { + return predicate.Card(sql.FieldContainsFold(FieldStatus, v)) +} + +// CpEQ applies the EQ predicate on the "cp" field. +func CpEQ(v int) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldCp, v)) +} + +// CpNEQ applies the NEQ predicate on the "cp" field. +func CpNEQ(v int) predicate.Card { + return predicate.Card(sql.FieldNEQ(FieldCp, v)) +} + +// CpIn applies the In predicate on the "cp" field. +func CpIn(vs ...int) predicate.Card { + return predicate.Card(sql.FieldIn(FieldCp, vs...)) +} + +// CpNotIn applies the NotIn predicate on the "cp" field. +func CpNotIn(vs ...int) predicate.Card { + return predicate.Card(sql.FieldNotIn(FieldCp, vs...)) +} + +// CpGT applies the GT predicate on the "cp" field. +func CpGT(v int) predicate.Card { + return predicate.Card(sql.FieldGT(FieldCp, v)) +} + +// CpGTE applies the GTE predicate on the "cp" field. +func CpGTE(v int) predicate.Card { + return predicate.Card(sql.FieldGTE(FieldCp, v)) +} + +// CpLT applies the LT predicate on the "cp" field. +func CpLT(v int) predicate.Card { + return predicate.Card(sql.FieldLT(FieldCp, v)) +} + +// CpLTE applies the LTE predicate on the "cp" field. +func CpLTE(v int) predicate.Card { + return predicate.Card(sql.FieldLTE(FieldCp, v)) +} + +// CpIsNil applies the IsNil predicate on the "cp" field. +func CpIsNil() predicate.Card { + return predicate.Card(sql.FieldIsNull(FieldCp)) +} + +// CpNotNil applies the NotNil predicate on the "cp" field. +func CpNotNil() predicate.Card { + return predicate.Card(sql.FieldNotNull(FieldCp)) +} + +// URLEQ applies the EQ predicate on the "url" field. +func URLEQ(v string) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldURL, v)) +} + +// URLNEQ applies the NEQ predicate on the "url" field. +func URLNEQ(v string) predicate.Card { + return predicate.Card(sql.FieldNEQ(FieldURL, v)) +} + +// URLIn applies the In predicate on the "url" field. +func URLIn(vs ...string) predicate.Card { + return predicate.Card(sql.FieldIn(FieldURL, vs...)) +} + +// URLNotIn applies the NotIn predicate on the "url" field. +func URLNotIn(vs ...string) predicate.Card { + return predicate.Card(sql.FieldNotIn(FieldURL, vs...)) +} + +// URLGT applies the GT predicate on the "url" field. +func URLGT(v string) predicate.Card { + return predicate.Card(sql.FieldGT(FieldURL, v)) +} + +// URLGTE applies the GTE predicate on the "url" field. +func URLGTE(v string) predicate.Card { + return predicate.Card(sql.FieldGTE(FieldURL, v)) +} + +// URLLT applies the LT predicate on the "url" field. +func URLLT(v string) predicate.Card { + return predicate.Card(sql.FieldLT(FieldURL, v)) +} + +// URLLTE applies the LTE predicate on the "url" field. +func URLLTE(v string) predicate.Card { + return predicate.Card(sql.FieldLTE(FieldURL, v)) +} + +// URLContains applies the Contains predicate on the "url" field. +func URLContains(v string) predicate.Card { + return predicate.Card(sql.FieldContains(FieldURL, v)) +} + +// URLHasPrefix applies the HasPrefix predicate on the "url" field. +func URLHasPrefix(v string) predicate.Card { + return predicate.Card(sql.FieldHasPrefix(FieldURL, v)) +} + +// URLHasSuffix applies the HasSuffix predicate on the "url" field. +func URLHasSuffix(v string) predicate.Card { + return predicate.Card(sql.FieldHasSuffix(FieldURL, v)) +} + +// URLIsNil applies the IsNil predicate on the "url" field. +func URLIsNil() predicate.Card { + return predicate.Card(sql.FieldIsNull(FieldURL)) +} + +// URLNotNil applies the NotNil predicate on the "url" field. +func URLNotNil() predicate.Card { + return predicate.Card(sql.FieldNotNull(FieldURL)) +} + +// URLEqualFold applies the EqualFold predicate on the "url" field. +func URLEqualFold(v string) predicate.Card { + return predicate.Card(sql.FieldEqualFold(FieldURL, v)) +} + +// URLContainsFold applies the ContainsFold predicate on the "url" field. +func URLContainsFold(v string) predicate.Card { + return predicate.Card(sql.FieldContainsFold(FieldURL, v)) +} + +// CreatedAtEQ applies the EQ predicate on the "created_at" field. +func CreatedAtEQ(v time.Time) predicate.Card { + return predicate.Card(sql.FieldEQ(FieldCreatedAt, v)) +} + +// CreatedAtNEQ applies the NEQ predicate on the "created_at" field. +func CreatedAtNEQ(v time.Time) predicate.Card { + return predicate.Card(sql.FieldNEQ(FieldCreatedAt, v)) +} + +// CreatedAtIn applies the In predicate on the "created_at" field. +func CreatedAtIn(vs ...time.Time) predicate.Card { + return predicate.Card(sql.FieldIn(FieldCreatedAt, vs...)) +} + +// CreatedAtNotIn applies the NotIn predicate on the "created_at" field. +func CreatedAtNotIn(vs ...time.Time) predicate.Card { + return predicate.Card(sql.FieldNotIn(FieldCreatedAt, vs...)) +} + +// CreatedAtGT applies the GT predicate on the "created_at" field. +func CreatedAtGT(v time.Time) predicate.Card { + return predicate.Card(sql.FieldGT(FieldCreatedAt, v)) +} + +// CreatedAtGTE applies the GTE predicate on the "created_at" field. +func CreatedAtGTE(v time.Time) predicate.Card { + return predicate.Card(sql.FieldGTE(FieldCreatedAt, v)) +} + +// CreatedAtLT applies the LT predicate on the "created_at" field. +func CreatedAtLT(v time.Time) predicate.Card { + return predicate.Card(sql.FieldLT(FieldCreatedAt, v)) +} + +// CreatedAtLTE applies the LTE predicate on the "created_at" field. +func CreatedAtLTE(v time.Time) predicate.Card { + return predicate.Card(sql.FieldLTE(FieldCreatedAt, v)) +} + +// CreatedAtIsNil applies the IsNil predicate on the "created_at" field. +func CreatedAtIsNil() predicate.Card { + return predicate.Card(sql.FieldIsNull(FieldCreatedAt)) +} + +// CreatedAtNotNil applies the NotNil predicate on the "created_at" field. +func CreatedAtNotNil() predicate.Card { + return predicate.Card(sql.FieldNotNull(FieldCreatedAt)) +} + +// HasOwner applies the HasEdge predicate on the "owner" edge. +func HasOwner() predicate.Card { + return predicate.Card(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.Card { + return predicate.Card(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(OwnerInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, OwnerTable, OwnerColumn), + ) + 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.Card) predicate.Card { + return predicate.Card(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.Card) predicate.Card { + return predicate.Card(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.Card) predicate.Card { + return predicate.Card(func(s *sql.Selector) { + p(s.Not()) + }) +} diff --git a/ent/card_create.go b/ent/card_create.go new file mode 100644 index 0000000..e8c1b55 --- /dev/null +++ b/ent/card_create.go @@ -0,0 +1,318 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "t/ent/card" + "t/ent/user" + "time" + + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// CardCreate is the builder for creating a Card entity. +type CardCreate struct { + config + mutation *CardMutation + hooks []Hook +} + +// SetCard sets the "card" field. +func (cc *CardCreate) SetCard(i int) *CardCreate { + cc.mutation.SetCard(i) + return cc +} + +// SetNillableCard sets the "card" field if the given value is not nil. +func (cc *CardCreate) SetNillableCard(i *int) *CardCreate { + if i != nil { + cc.SetCard(*i) + } + return cc +} + +// SetStatus sets the "status" field. +func (cc *CardCreate) SetStatus(s string) *CardCreate { + cc.mutation.SetStatus(s) + return cc +} + +// SetNillableStatus sets the "status" field if the given value is not nil. +func (cc *CardCreate) SetNillableStatus(s *string) *CardCreate { + if s != nil { + cc.SetStatus(*s) + } + return cc +} + +// SetCp sets the "cp" field. +func (cc *CardCreate) SetCp(i int) *CardCreate { + cc.mutation.SetCp(i) + return cc +} + +// SetNillableCp sets the "cp" field if the given value is not nil. +func (cc *CardCreate) SetNillableCp(i *int) *CardCreate { + if i != nil { + cc.SetCp(*i) + } + return cc +} + +// SetURL sets the "url" field. +func (cc *CardCreate) SetURL(s string) *CardCreate { + cc.mutation.SetURL(s) + return cc +} + +// SetNillableURL sets the "url" field if the given value is not nil. +func (cc *CardCreate) SetNillableURL(s *string) *CardCreate { + if s != nil { + cc.SetURL(*s) + } + return cc +} + +// SetCreatedAt sets the "created_at" field. +func (cc *CardCreate) SetCreatedAt(t time.Time) *CardCreate { + cc.mutation.SetCreatedAt(t) + return cc +} + +// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. +func (cc *CardCreate) SetNillableCreatedAt(t *time.Time) *CardCreate { + if t != nil { + cc.SetCreatedAt(*t) + } + return cc +} + +// SetOwnerID sets the "owner" edge to the User entity by ID. +func (cc *CardCreate) SetOwnerID(id int) *CardCreate { + cc.mutation.SetOwnerID(id) + return cc +} + +// SetOwner sets the "owner" edge to the User entity. +func (cc *CardCreate) SetOwner(u *User) *CardCreate { + return cc.SetOwnerID(u.ID) +} + +// Mutation returns the CardMutation object of the builder. +func (cc *CardCreate) Mutation() *CardMutation { + return cc.mutation +} + +// Save creates the Card in the database. +func (cc *CardCreate) Save(ctx context.Context) (*Card, error) { + cc.defaults() + return withHooks[*Card, CardMutation](ctx, cc.sqlSave, cc.mutation, cc.hooks) +} + +// SaveX calls Save and panics if Save returns an error. +func (cc *CardCreate) SaveX(ctx context.Context) *Card { + v, err := cc.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (cc *CardCreate) Exec(ctx context.Context) error { + _, err := cc.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (cc *CardCreate) ExecX(ctx context.Context) { + if err := cc.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (cc *CardCreate) defaults() { + if _, ok := cc.mutation.Card(); !ok { + v := card.DefaultCard() + cc.mutation.SetCard(v) + } + if _, ok := cc.mutation.Status(); !ok { + v := card.DefaultStatus() + cc.mutation.SetStatus(v) + } + if _, ok := cc.mutation.Cp(); !ok { + v := card.DefaultCp() + cc.mutation.SetCp(v) + } + if _, ok := cc.mutation.URL(); !ok { + v := card.DefaultURL + cc.mutation.SetURL(v) + } + if _, ok := cc.mutation.CreatedAt(); !ok { + v := card.DefaultCreatedAt() + cc.mutation.SetCreatedAt(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (cc *CardCreate) check() error { + if _, ok := cc.mutation.OwnerID(); !ok { + return &ValidationError{Name: "owner", err: errors.New(`ent: missing required edge "Card.owner"`)} + } + return nil +} + +func (cc *CardCreate) sqlSave(ctx context.Context) (*Card, error) { + if err := cc.check(); err != nil { + return nil, err + } + _node, _spec := cc.createSpec() + if err := sqlgraph.CreateNode(ctx, cc.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) + cc.mutation.id = &_node.ID + cc.mutation.done = true + return _node, nil +} + +func (cc *CardCreate) createSpec() (*Card, *sqlgraph.CreateSpec) { + var ( + _node = &Card{config: cc.config} + _spec = sqlgraph.NewCreateSpec(card.Table, sqlgraph.NewFieldSpec(card.FieldID, field.TypeInt)) + ) + if value, ok := cc.mutation.Card(); ok { + _spec.SetField(card.FieldCard, field.TypeInt, value) + _node.Card = value + } + if value, ok := cc.mutation.Status(); ok { + _spec.SetField(card.FieldStatus, field.TypeString, value) + _node.Status = value + } + if value, ok := cc.mutation.Cp(); ok { + _spec.SetField(card.FieldCp, field.TypeInt, value) + _node.Cp = value + } + if value, ok := cc.mutation.URL(); ok { + _spec.SetField(card.FieldURL, field.TypeString, value) + _node.URL = value + } + if value, ok := cc.mutation.CreatedAt(); ok { + _spec.SetField(card.FieldCreatedAt, field.TypeTime, value) + _node.CreatedAt = value + } + if nodes := cc.mutation.OwnerIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: card.OwnerTable, + Columns: []string{card.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.user_card = &nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + return _node, _spec +} + +// CardCreateBulk is the builder for creating many Card entities in bulk. +type CardCreateBulk struct { + config + builders []*CardCreate +} + +// Save creates the Card entities in the database. +func (ccb *CardCreateBulk) Save(ctx context.Context) ([]*Card, error) { + specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) + nodes := make([]*Card, len(ccb.builders)) + mutators := make([]Mutator, len(ccb.builders)) + for i := range ccb.builders { + func(i int, root context.Context) { + builder := ccb.builders[i] + builder.defaults() + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*CardMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + nodes[i], specs[i] = builder.createSpec() + var err error + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, ccb.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, ccb.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, ccb.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (ccb *CardCreateBulk) SaveX(ctx context.Context) []*Card { + v, err := ccb.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (ccb *CardCreateBulk) Exec(ctx context.Context) error { + _, err := ccb.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (ccb *CardCreateBulk) ExecX(ctx context.Context) { + if err := ccb.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/ent/card_delete.go b/ent/card_delete.go new file mode 100644 index 0000000..6682804 --- /dev/null +++ b/ent/card_delete.go @@ -0,0 +1,88 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "t/ent/card" + "t/ent/predicate" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// CardDelete is the builder for deleting a Card entity. +type CardDelete struct { + config + hooks []Hook + mutation *CardMutation +} + +// Where appends a list predicates to the CardDelete builder. +func (cd *CardDelete) Where(ps ...predicate.Card) *CardDelete { + cd.mutation.Where(ps...) + return cd +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (cd *CardDelete) Exec(ctx context.Context) (int, error) { + return withHooks[int, CardMutation](ctx, cd.sqlExec, cd.mutation, cd.hooks) +} + +// ExecX is like Exec, but panics if an error occurs. +func (cd *CardDelete) ExecX(ctx context.Context) int { + n, err := cd.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +func (cd *CardDelete) sqlExec(ctx context.Context) (int, error) { + _spec := sqlgraph.NewDeleteSpec(card.Table, sqlgraph.NewFieldSpec(card.FieldID, field.TypeInt)) + if ps := cd.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, cd.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + cd.mutation.done = true + return affected, err +} + +// CardDeleteOne is the builder for deleting a single Card entity. +type CardDeleteOne struct { + cd *CardDelete +} + +// Where appends a list predicates to the CardDelete builder. +func (cdo *CardDeleteOne) Where(ps ...predicate.Card) *CardDeleteOne { + cdo.cd.mutation.Where(ps...) + return cdo +} + +// Exec executes the deletion query. +func (cdo *CardDeleteOne) Exec(ctx context.Context) error { + n, err := cdo.cd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{card.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (cdo *CardDeleteOne) ExecX(ctx context.Context) { + if err := cdo.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/ent/card_query.go b/ent/card_query.go new file mode 100644 index 0000000..6d774cf --- /dev/null +++ b/ent/card_query.go @@ -0,0 +1,613 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "fmt" + "math" + "t/ent/card" + "t/ent/predicate" + "t/ent/user" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// CardQuery is the builder for querying Card entities. +type CardQuery struct { + config + ctx *QueryContext + order []OrderFunc + inters []Interceptor + predicates []predicate.Card + 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 CardQuery builder. +func (cq *CardQuery) Where(ps ...predicate.Card) *CardQuery { + cq.predicates = append(cq.predicates, ps...) + return cq +} + +// Limit the number of records to be returned by this query. +func (cq *CardQuery) Limit(limit int) *CardQuery { + cq.ctx.Limit = &limit + return cq +} + +// Offset to start from. +func (cq *CardQuery) Offset(offset int) *CardQuery { + cq.ctx.Offset = &offset + return cq +} + +// 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 (cq *CardQuery) Unique(unique bool) *CardQuery { + cq.ctx.Unique = &unique + return cq +} + +// Order specifies how the records should be ordered. +func (cq *CardQuery) Order(o ...OrderFunc) *CardQuery { + cq.order = append(cq.order, o...) + return cq +} + +// QueryOwner chains the current query on the "owner" edge. +func (cq *CardQuery) QueryOwner() *UserQuery { + query := (&UserClient{config: cq.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := cq.prepareQuery(ctx); err != nil { + return nil, err + } + selector := cq.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(card.Table, card.FieldID, selector), + sqlgraph.To(user.Table, user.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, card.OwnerTable, card.OwnerColumn), + ) + fromU = sqlgraph.SetNeighbors(cq.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// First returns the first Card entity from the query. +// Returns a *NotFoundError when no Card was found. +func (cq *CardQuery) First(ctx context.Context) (*Card, error) { + nodes, err := cq.Limit(1).All(setContextOp(ctx, cq.ctx, "First")) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{card.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (cq *CardQuery) FirstX(ctx context.Context) *Card { + node, err := cq.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first Card ID from the query. +// Returns a *NotFoundError when no Card ID was found. +func (cq *CardQuery) FirstID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = cq.Limit(1).IDs(setContextOp(ctx, cq.ctx, "FirstID")); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{card.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (cq *CardQuery) FirstIDX(ctx context.Context) int { + id, err := cq.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single Card entity found by the query, ensuring it only returns one. +// Returns a *NotSingularError when more than one Card entity is found. +// Returns a *NotFoundError when no Card entities are found. +func (cq *CardQuery) Only(ctx context.Context) (*Card, error) { + nodes, err := cq.Limit(2).All(setContextOp(ctx, cq.ctx, "Only")) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{card.Label} + default: + return nil, &NotSingularError{card.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (cq *CardQuery) OnlyX(ctx context.Context) *Card { + node, err := cq.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only Card ID in the query. +// Returns a *NotSingularError when more than one Card ID is found. +// Returns a *NotFoundError when no entities are found. +func (cq *CardQuery) OnlyID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = cq.Limit(2).IDs(setContextOp(ctx, cq.ctx, "OnlyID")); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{card.Label} + default: + err = &NotSingularError{card.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (cq *CardQuery) OnlyIDX(ctx context.Context) int { + id, err := cq.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of Cards. +func (cq *CardQuery) All(ctx context.Context) ([]*Card, error) { + ctx = setContextOp(ctx, cq.ctx, "All") + if err := cq.prepareQuery(ctx); err != nil { + return nil, err + } + qr := querierAll[[]*Card, *CardQuery]() + return withInterceptors[[]*Card](ctx, cq, qr, cq.inters) +} + +// AllX is like All, but panics if an error occurs. +func (cq *CardQuery) AllX(ctx context.Context) []*Card { + nodes, err := cq.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// IDs executes the query and returns a list of Card IDs. +func (cq *CardQuery) IDs(ctx context.Context) (ids []int, err error) { + if cq.ctx.Unique == nil && cq.path != nil { + cq.Unique(true) + } + ctx = setContextOp(ctx, cq.ctx, "IDs") + if err = cq.Select(card.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (cq *CardQuery) IDsX(ctx context.Context) []int { + ids, err := cq.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (cq *CardQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, cq.ctx, "Count") + if err := cq.prepareQuery(ctx); err != nil { + return 0, err + } + return withInterceptors[int](ctx, cq, querierCount[*CardQuery](), cq.inters) +} + +// CountX is like Count, but panics if an error occurs. +func (cq *CardQuery) CountX(ctx context.Context) int { + count, err := cq.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (cq *CardQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, cq.ctx, "Exist") + switch _, err := cq.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 (cq *CardQuery) ExistX(ctx context.Context) bool { + exist, err := cq.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the CardQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (cq *CardQuery) Clone() *CardQuery { + if cq == nil { + return nil + } + return &CardQuery{ + config: cq.config, + ctx: cq.ctx.Clone(), + order: append([]OrderFunc{}, cq.order...), + inters: append([]Interceptor{}, cq.inters...), + predicates: append([]predicate.Card{}, cq.predicates...), + withOwner: cq.withOwner.Clone(), + // clone intermediate query. + sql: cq.sql.Clone(), + path: cq.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 (cq *CardQuery) WithOwner(opts ...func(*UserQuery)) *CardQuery { + query := (&UserClient{config: cq.config}).Query() + for _, opt := range opts { + opt(query) + } + cq.withOwner = query + return cq +} + +// 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 { +// Card int `json:"card,omitempty"` +// Count int `json:"count,omitempty"` +// } +// +// client.Card.Query(). +// GroupBy(card.FieldCard). +// Aggregate(ent.Count()). +// Scan(ctx, &v) +func (cq *CardQuery) GroupBy(field string, fields ...string) *CardGroupBy { + cq.ctx.Fields = append([]string{field}, fields...) + grbuild := &CardGroupBy{build: cq} + grbuild.flds = &cq.ctx.Fields + grbuild.label = card.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 { +// Card int `json:"card,omitempty"` +// } +// +// client.Card.Query(). +// Select(card.FieldCard). +// Scan(ctx, &v) +func (cq *CardQuery) Select(fields ...string) *CardSelect { + cq.ctx.Fields = append(cq.ctx.Fields, fields...) + sbuild := &CardSelect{CardQuery: cq} + sbuild.label = card.Label + sbuild.flds, sbuild.scan = &cq.ctx.Fields, sbuild.Scan + return sbuild +} + +// Aggregate returns a CardSelect configured with the given aggregations. +func (cq *CardQuery) Aggregate(fns ...AggregateFunc) *CardSelect { + return cq.Select().Aggregate(fns...) +} + +func (cq *CardQuery) prepareQuery(ctx context.Context) error { + for _, inter := range cq.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, cq); err != nil { + return err + } + } + } + for _, f := range cq.ctx.Fields { + if !card.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + } + if cq.path != nil { + prev, err := cq.path(ctx) + if err != nil { + return err + } + cq.sql = prev + } + return nil +} + +func (cq *CardQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Card, error) { + var ( + nodes = []*Card{} + withFKs = cq.withFKs + _spec = cq.querySpec() + loadedTypes = [1]bool{ + cq.withOwner != nil, + } + ) + if cq.withOwner != nil { + withFKs = true + } + if withFKs { + _spec.Node.Columns = append(_spec.Node.Columns, card.ForeignKeys...) + } + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*Card).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &Card{config: cq.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, cq.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + if query := cq.withOwner; query != nil { + if err := cq.loadOwner(ctx, query, nodes, nil, + func(n *Card, e *User) { n.Edges.Owner = e }); err != nil { + return nil, err + } + } + return nodes, nil +} + +func (cq *CardQuery) loadOwner(ctx context.Context, query *UserQuery, nodes []*Card, init func(*Card), assign func(*Card, *User)) error { + ids := make([]int, 0, len(nodes)) + nodeids := make(map[int][]*Card) + for i := range nodes { + if nodes[i].user_card == nil { + continue + } + fk := *nodes[i].user_card + 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_card" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} + +func (cq *CardQuery) sqlCount(ctx context.Context) (int, error) { + _spec := cq.querySpec() + _spec.Node.Columns = cq.ctx.Fields + if len(cq.ctx.Fields) > 0 { + _spec.Unique = cq.ctx.Unique != nil && *cq.ctx.Unique + } + return sqlgraph.CountNodes(ctx, cq.driver, _spec) +} + +func (cq *CardQuery) querySpec() *sqlgraph.QuerySpec { + _spec := sqlgraph.NewQuerySpec(card.Table, card.Columns, sqlgraph.NewFieldSpec(card.FieldID, field.TypeInt)) + _spec.From = cq.sql + if unique := cq.ctx.Unique; unique != nil { + _spec.Unique = *unique + } else if cq.path != nil { + _spec.Unique = true + } + if fields := cq.ctx.Fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, card.FieldID) + for i := range fields { + if fields[i] != card.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + } + if ps := cq.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := cq.ctx.Limit; limit != nil { + _spec.Limit = *limit + } + if offset := cq.ctx.Offset; offset != nil { + _spec.Offset = *offset + } + if ps := cq.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (cq *CardQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(cq.driver.Dialect()) + t1 := builder.Table(card.Table) + columns := cq.ctx.Fields + if len(columns) == 0 { + columns = card.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if cq.sql != nil { + selector = cq.sql + selector.Select(selector.Columns(columns...)...) + } + if cq.ctx.Unique != nil && *cq.ctx.Unique { + selector.Distinct() + } + for _, p := range cq.predicates { + p(selector) + } + for _, p := range cq.order { + p(selector) + } + if offset := cq.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 := cq.ctx.Limit; limit != nil { + selector.Limit(*limit) + } + return selector +} + +// CardGroupBy is the group-by builder for Card entities. +type CardGroupBy struct { + selector + build *CardQuery +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (cgb *CardGroupBy) Aggregate(fns ...AggregateFunc) *CardGroupBy { + cgb.fns = append(cgb.fns, fns...) + return cgb +} + +// Scan applies the selector query and scans the result into the given value. +func (cgb *CardGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, cgb.build.ctx, "GroupBy") + if err := cgb.build.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*CardQuery, *CardGroupBy](ctx, cgb.build, cgb, cgb.build.inters, v) +} + +func (cgb *CardGroupBy) sqlScan(ctx context.Context, root *CardQuery, v any) error { + selector := root.sqlQuery(ctx).Select() + aggregation := make([]string, 0, len(cgb.fns)) + for _, fn := range cgb.fns { + aggregation = append(aggregation, fn(selector)) + } + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(*cgb.flds)+len(cgb.fns)) + for _, f := range *cgb.flds { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + selector.GroupBy(selector.Columns(*cgb.flds...)...) + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := cgb.build.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// CardSelect is the builder for selecting fields of Card entities. +type CardSelect struct { + *CardQuery + selector +} + +// Aggregate adds the given aggregation functions to the selector query. +func (cs *CardSelect) Aggregate(fns ...AggregateFunc) *CardSelect { + cs.fns = append(cs.fns, fns...) + return cs +} + +// Scan applies the selector query and scans the result into the given value. +func (cs *CardSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, cs.ctx, "Select") + if err := cs.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*CardQuery, *CardSelect](ctx, cs.CardQuery, cs, cs.inters, v) +} + +func (cs *CardSelect) sqlScan(ctx context.Context, root *CardQuery, v any) error { + selector := root.sqlQuery(ctx) + aggregation := make([]string, 0, len(cs.fns)) + for _, fn := range cs.fns { + aggregation = append(aggregation, fn(selector)) + } + switch n := len(*cs.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 := cs.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} diff --git a/ent/card_update.go b/ent/card_update.go new file mode 100644 index 0000000..8646b24 --- /dev/null +++ b/ent/card_update.go @@ -0,0 +1,332 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "t/ent/card" + "t/ent/predicate" + "t/ent/user" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// CardUpdate is the builder for updating Card entities. +type CardUpdate struct { + config + hooks []Hook + mutation *CardMutation +} + +// Where appends a list predicates to the CardUpdate builder. +func (cu *CardUpdate) Where(ps ...predicate.Card) *CardUpdate { + cu.mutation.Where(ps...) + return cu +} + +// SetOwnerID sets the "owner" edge to the User entity by ID. +func (cu *CardUpdate) SetOwnerID(id int) *CardUpdate { + cu.mutation.SetOwnerID(id) + return cu +} + +// SetOwner sets the "owner" edge to the User entity. +func (cu *CardUpdate) SetOwner(u *User) *CardUpdate { + return cu.SetOwnerID(u.ID) +} + +// Mutation returns the CardMutation object of the builder. +func (cu *CardUpdate) Mutation() *CardMutation { + return cu.mutation +} + +// ClearOwner clears the "owner" edge to the User entity. +func (cu *CardUpdate) ClearOwner() *CardUpdate { + cu.mutation.ClearOwner() + return cu +} + +// Save executes the query and returns the number of nodes affected by the update operation. +func (cu *CardUpdate) Save(ctx context.Context) (int, error) { + return withHooks[int, CardMutation](ctx, cu.sqlSave, cu.mutation, cu.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (cu *CardUpdate) SaveX(ctx context.Context) int { + affected, err := cu.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (cu *CardUpdate) Exec(ctx context.Context) error { + _, err := cu.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (cu *CardUpdate) ExecX(ctx context.Context) { + if err := cu.Exec(ctx); err != nil { + panic(err) + } +} + +// check runs all checks and user-defined validators on the builder. +func (cu *CardUpdate) check() error { + if _, ok := cu.mutation.OwnerID(); cu.mutation.OwnerCleared() && !ok { + return errors.New(`ent: clearing a required unique edge "Card.owner"`) + } + return nil +} + +func (cu *CardUpdate) sqlSave(ctx context.Context) (n int, err error) { + if err := cu.check(); err != nil { + return n, err + } + _spec := sqlgraph.NewUpdateSpec(card.Table, card.Columns, sqlgraph.NewFieldSpec(card.FieldID, field.TypeInt)) + if ps := cu.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if cu.mutation.CardCleared() { + _spec.ClearField(card.FieldCard, field.TypeInt) + } + if cu.mutation.StatusCleared() { + _spec.ClearField(card.FieldStatus, field.TypeString) + } + if cu.mutation.CpCleared() { + _spec.ClearField(card.FieldCp, field.TypeInt) + } + if cu.mutation.URLCleared() { + _spec.ClearField(card.FieldURL, field.TypeString) + } + if cu.mutation.CreatedAtCleared() { + _spec.ClearField(card.FieldCreatedAt, field.TypeTime) + } + if cu.mutation.OwnerCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: card.OwnerTable, + Columns: []string{card.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := cu.mutation.OwnerIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: card.OwnerTable, + Columns: []string{card.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + 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, cu.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{card.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + cu.mutation.done = true + return n, nil +} + +// CardUpdateOne is the builder for updating a single Card entity. +type CardUpdateOne struct { + config + fields []string + hooks []Hook + mutation *CardMutation +} + +// SetOwnerID sets the "owner" edge to the User entity by ID. +func (cuo *CardUpdateOne) SetOwnerID(id int) *CardUpdateOne { + cuo.mutation.SetOwnerID(id) + return cuo +} + +// SetOwner sets the "owner" edge to the User entity. +func (cuo *CardUpdateOne) SetOwner(u *User) *CardUpdateOne { + return cuo.SetOwnerID(u.ID) +} + +// Mutation returns the CardMutation object of the builder. +func (cuo *CardUpdateOne) Mutation() *CardMutation { + return cuo.mutation +} + +// ClearOwner clears the "owner" edge to the User entity. +func (cuo *CardUpdateOne) ClearOwner() *CardUpdateOne { + cuo.mutation.ClearOwner() + return cuo +} + +// Where appends a list predicates to the CardUpdate builder. +func (cuo *CardUpdateOne) Where(ps ...predicate.Card) *CardUpdateOne { + cuo.mutation.Where(ps...) + return cuo +} + +// Select allows selecting one or more fields (columns) of the returned entity. +// The default is selecting all fields defined in the entity schema. +func (cuo *CardUpdateOne) Select(field string, fields ...string) *CardUpdateOne { + cuo.fields = append([]string{field}, fields...) + return cuo +} + +// Save executes the query and returns the updated Card entity. +func (cuo *CardUpdateOne) Save(ctx context.Context) (*Card, error) { + return withHooks[*Card, CardMutation](ctx, cuo.sqlSave, cuo.mutation, cuo.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (cuo *CardUpdateOne) SaveX(ctx context.Context) *Card { + node, err := cuo.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (cuo *CardUpdateOne) Exec(ctx context.Context) error { + _, err := cuo.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (cuo *CardUpdateOne) ExecX(ctx context.Context) { + if err := cuo.Exec(ctx); err != nil { + panic(err) + } +} + +// check runs all checks and user-defined validators on the builder. +func (cuo *CardUpdateOne) check() error { + if _, ok := cuo.mutation.OwnerID(); cuo.mutation.OwnerCleared() && !ok { + return errors.New(`ent: clearing a required unique edge "Card.owner"`) + } + return nil +} + +func (cuo *CardUpdateOne) sqlSave(ctx context.Context) (_node *Card, err error) { + if err := cuo.check(); err != nil { + return _node, err + } + _spec := sqlgraph.NewUpdateSpec(card.Table, card.Columns, sqlgraph.NewFieldSpec(card.FieldID, field.TypeInt)) + id, ok := cuo.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Card.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := cuo.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, card.FieldID) + for _, f := range fields { + if !card.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + if f != card.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := cuo.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if cuo.mutation.CardCleared() { + _spec.ClearField(card.FieldCard, field.TypeInt) + } + if cuo.mutation.StatusCleared() { + _spec.ClearField(card.FieldStatus, field.TypeString) + } + if cuo.mutation.CpCleared() { + _spec.ClearField(card.FieldCp, field.TypeInt) + } + if cuo.mutation.URLCleared() { + _spec.ClearField(card.FieldURL, field.TypeString) + } + if cuo.mutation.CreatedAtCleared() { + _spec.ClearField(card.FieldCreatedAt, field.TypeTime) + } + if cuo.mutation.OwnerCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: card.OwnerTable, + Columns: []string{card.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := cuo.mutation.OwnerIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: card.OwnerTable, + Columns: []string{card.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + _node = &Card{config: cuo.config} + _spec.Assign = _node.assignValues + _spec.ScanValues = _node.scanValues + if err = sqlgraph.UpdateNode(ctx, cuo.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{card.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + cuo.mutation.done = true + return _node, nil +} diff --git a/ent/client.go b/ent/client.go index e9f5a9b..4c69383 100644 --- a/ent/client.go +++ b/ent/client.go @@ -1,18 +1,23 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package ent import ( "context" + "errors" "fmt" "log" "t/ent/migrate" - "t/ent/users" + "t/ent/card" + "t/ent/group" + "t/ent/user" + "entgo.io/ent" "entgo.io/ent/dialect" "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" ) // Client is the client that holds all ent builders. @@ -20,13 +25,17 @@ type Client struct { config // Schema is the client for creating, migrating and dropping schema. Schema *migrate.Schema - // Users is the client for interacting with the Users builders. - Users *UsersClient + // Card is the client for interacting with the Card builders. + Card *CardClient + // Group is the client for interacting with the Group builders. + Group *GroupClient + // User is the client for interacting with the User builders. + User *UserClient } // NewClient creates a new client configured with the given options. func NewClient(opts ...Option) *Client { - cfg := config{log: log.Println, hooks: &hooks{}} + cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}} cfg.options(opts...) client := &Client{config: cfg} client.init() @@ -35,7 +44,58 @@ func NewClient(opts ...Option) *Client { func (c *Client) init() { c.Schema = migrate.NewSchema(c.driver) - c.Users = NewUsersClient(c.config) + c.Card = NewCardClient(c.config) + c.Group = NewGroupClient(c.config) + c.User = NewUserClient(c.config) +} + +type ( + // config is the configuration for the client and its builder. + config struct { + // driver used for executing database requests. + driver dialect.Driver + // debug enable a debug logging. + debug bool + // log used for logging on debug mode. + log func(...any) + // hooks to execute on mutations. + hooks *hooks + // interceptors to execute on queries. + inters *inters + } + // Option function to configure the client. + Option func(*config) +) + +// options applies the options on the config object. +func (c *config) options(opts ...Option) { + for _, opt := range opts { + opt(c) + } + if c.debug { + c.driver = dialect.Debug(c.driver, c.log) + } +} + +// Debug enables debug logging on the ent.Driver. +func Debug() Option { + return func(c *config) { + c.debug = true + } +} + +// Log sets the logging function for debug mode. +func Log(fn func(...any)) Option { + return func(c *config) { + c.log = fn + } +} + +// Driver configures the client driver. +func Driver(driver dialect.Driver) Option { + return func(c *config) { + c.driver = driver + } } // Open opens a database/sql.DB specified by the driver name and @@ -58,7 +118,7 @@ func Open(driverName, dataSourceName string, options ...Option) (*Client, error) // is used until the transaction is committed or rolled back. func (c *Client) Tx(ctx context.Context) (*Tx, error) { if _, ok := c.driver.(*txDriver); ok { - return nil, fmt.Errorf("ent: cannot start a transaction within a transaction") + return nil, errors.New("ent: cannot start a transaction within a transaction") } tx, err := newTx(ctx, c.driver) if err != nil { @@ -69,14 +129,16 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) { return &Tx{ ctx: ctx, config: cfg, - Users: NewUsersClient(cfg), + Card: NewCardClient(cfg), + Group: NewGroupClient(cfg), + User: NewUserClient(cfg), }, nil } // BeginTx returns a transactional client with specified options. func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) { if _, ok := c.driver.(*txDriver); ok { - return nil, fmt.Errorf("ent: cannot start a transaction within a transaction") + return nil, errors.New("ent: cannot start a transaction within a transaction") } tx, err := c.driver.(interface { BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error) @@ -89,17 +151,18 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) return &Tx{ ctx: ctx, config: cfg, - Users: NewUsersClient(cfg), + Card: NewCardClient(cfg), + Group: NewGroupClient(cfg), + User: NewUserClient(cfg), }, nil } // Debug returns a new debug-client. It's used to get verbose logging on specific operations. // // client.Debug(). -// Users. +// Card. // Query(). // Count(ctx) -// func (c *Client) Debug() *Client { if c.debug { return c @@ -119,87 +182,119 @@ 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.Users.Use(hooks...) + c.Card.Use(hooks...) + c.Group.Use(hooks...) + c.User.Use(hooks...) } -// UsersClient is a client for the Users schema. -type UsersClient struct { - config +// 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.User.Intercept(interceptors...) } -// NewUsersClient returns a client for the Users from the given config. -func NewUsersClient(c config) *UsersClient { - return &UsersClient{config: c} -} - -// Use adds a list of mutation hooks to the hooks stack. -// A call to `Use(f, g, h)` equals to `users.Hooks(f(g(h())))`. -func (c *UsersClient) Use(hooks ...Hook) { - c.hooks.Users = append(c.hooks.Users, hooks...) -} - -// Create returns a create builder for Users. -func (c *UsersClient) Create() *UsersCreate { - mutation := newUsersMutation(c.config, OpCreate) - return &UsersCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} -} - -// CreateBulk returns a builder for creating a bulk of Users entities. -func (c *UsersClient) CreateBulk(builders ...*UsersCreate) *UsersCreateBulk { - return &UsersCreateBulk{config: c.config, builders: builders} -} - -// Update returns an update builder for Users. -func (c *UsersClient) Update() *UsersUpdate { - mutation := newUsersMutation(c.config, OpUpdate) - return &UsersUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} -} - -// UpdateOne returns an update builder for the given entity. -func (c *UsersClient) UpdateOne(u *Users) *UsersUpdateOne { - mutation := newUsersMutation(c.config, OpUpdateOne, withUsers(u)) - return &UsersUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} -} - -// UpdateOneID returns an update builder for the given id. -func (c *UsersClient) UpdateOneID(id int) *UsersUpdateOne { - mutation := newUsersMutation(c.config, OpUpdateOne, withUsersID(id)) - return &UsersUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} -} - -// Delete returns a delete builder for Users. -func (c *UsersClient) Delete() *UsersDelete { - mutation := newUsersMutation(c.config, OpDelete) - return &UsersDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} -} - -// DeleteOne returns a delete builder for the given entity. -func (c *UsersClient) DeleteOne(u *Users) *UsersDeleteOne { - return c.DeleteOneID(u.ID) -} - -// DeleteOneID returns a delete builder for the given id. -func (c *UsersClient) DeleteOneID(id int) *UsersDeleteOne { - builder := c.Delete().Where(users.ID(id)) - builder.mutation.id = &id - builder.mutation.op = OpDeleteOne - return &UsersDeleteOne{builder} -} - -// Query returns a query builder for Users. -func (c *UsersClient) Query() *UsersQuery { - return &UsersQuery{ - config: c.config, +// Mutate implements the ent.Mutator interface. +func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) { + switch m := m.(type) { + case *CardMutation: + return c.Card.mutate(ctx, m) + case *GroupMutation: + return c.Group.mutate(ctx, m) + case *UserMutation: + return c.User.mutate(ctx, m) + default: + return nil, fmt.Errorf("ent: unknown mutation type %T", m) } } -// Get returns a Users entity by its id. -func (c *UsersClient) Get(ctx context.Context, id int) (*Users, error) { - return c.Query().Where(users.ID(id)).Only(ctx) +// CardClient is a client for the Card schema. +type CardClient struct { + config +} + +// NewCardClient returns a client for the Card from the given config. +func NewCardClient(c config) *CardClient { + return &CardClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `card.Hooks(f(g(h())))`. +func (c *CardClient) Use(hooks ...Hook) { + c.hooks.Card = append(c.hooks.Card, hooks...) +} + +// Intercept adds a list of query interceptors to the interceptors stack. +// A call to `Intercept(f, g, h)` equals to `card.Intercept(f(g(h())))`. +func (c *CardClient) Intercept(interceptors ...Interceptor) { + c.inters.Card = append(c.inters.Card, interceptors...) +} + +// Create returns a builder for creating a Card entity. +func (c *CardClient) Create() *CardCreate { + mutation := newCardMutation(c.config, OpCreate) + return &CardCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of Card entities. +func (c *CardClient) CreateBulk(builders ...*CardCreate) *CardCreateBulk { + return &CardCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for Card. +func (c *CardClient) Update() *CardUpdate { + mutation := newCardMutation(c.config, OpUpdate) + return &CardUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *CardClient) UpdateOne(ca *Card) *CardUpdateOne { + mutation := newCardMutation(c.config, OpUpdateOne, withCard(ca)) + return &CardUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *CardClient) UpdateOneID(id int) *CardUpdateOne { + mutation := newCardMutation(c.config, OpUpdateOne, withCardID(id)) + return &CardUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for Card. +func (c *CardClient) Delete() *CardDelete { + mutation := newCardMutation(c.config, OpDelete) + return &CardDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *CardClient) DeleteOne(ca *Card) *CardDeleteOne { + return c.DeleteOneID(ca.ID) +} + +// DeleteOneID returns a builder for deleting the given entity by its id. +func (c *CardClient) DeleteOneID(id int) *CardDeleteOne { + builder := c.Delete().Where(card.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &CardDeleteOne{builder} +} + +// Query returns a query builder for Card. +func (c *CardClient) Query() *CardQuery { + return &CardQuery{ + config: c.config, + ctx: &QueryContext{Type: TypeCard}, + inters: c.Interceptors(), + } +} + +// Get returns a Card entity by its id. +func (c *CardClient) Get(ctx context.Context, id int) (*Card, error) { + return c.Query().Where(card.ID(id)).Only(ctx) } // GetX is like Get, but panics if an error occurs. -func (c *UsersClient) GetX(ctx context.Context, id int) *Users { +func (c *CardClient) GetX(ctx context.Context, id int) *Card { obj, err := c.Get(ctx, id) if err != nil { panic(err) @@ -207,7 +302,321 @@ func (c *UsersClient) GetX(ctx context.Context, id int) *Users { return obj } -// Hooks returns the client hooks. -func (c *UsersClient) Hooks() []Hook { - return c.hooks.Users +// QueryOwner queries the owner edge of a Card. +func (c *CardClient) QueryOwner(ca *Card) *UserQuery { + query := (&UserClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := ca.ID + step := sqlgraph.NewStep( + sqlgraph.From(card.Table, card.FieldID, id), + sqlgraph.To(user.Table, user.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, card.OwnerTable, card.OwnerColumn), + ) + fromV = sqlgraph.Neighbors(ca.driver.Dialect(), step) + return fromV, nil + } + return query } + +// Hooks returns the client hooks. +func (c *CardClient) Hooks() []Hook { + return c.hooks.Card +} + +// Interceptors returns the client interceptors. +func (c *CardClient) Interceptors() []Interceptor { + return c.inters.Card +} + +func (c *CardClient) mutate(ctx context.Context, m *CardMutation) (Value, error) { + switch m.Op() { + case OpCreate: + return (&CardCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdate: + return (&CardUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdateOne: + return (&CardUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpDelete, OpDeleteOne: + return (&CardDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx) + default: + return nil, fmt.Errorf("ent: unknown Card mutation op: %q", m.Op()) + } +} + +// GroupClient is a client for the Group schema. +type GroupClient struct { + config +} + +// NewGroupClient returns a client for the Group from the given config. +func NewGroupClient(c config) *GroupClient { + return &GroupClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `group.Hooks(f(g(h())))`. +func (c *GroupClient) Use(hooks ...Hook) { + c.hooks.Group = append(c.hooks.Group, hooks...) +} + +// Intercept adds a list of query interceptors to the interceptors stack. +// A call to `Intercept(f, g, h)` equals to `group.Intercept(f(g(h())))`. +func (c *GroupClient) Intercept(interceptors ...Interceptor) { + c.inters.Group = append(c.inters.Group, interceptors...) +} + +// Create returns a builder for creating a Group entity. +func (c *GroupClient) Create() *GroupCreate { + mutation := newGroupMutation(c.config, OpCreate) + return &GroupCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of Group entities. +func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { + return &GroupCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for Group. +func (c *GroupClient) Update() *GroupUpdate { + mutation := newGroupMutation(c.config, OpUpdate) + return &GroupUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *GroupClient) UpdateOne(gr *Group) *GroupUpdateOne { + mutation := newGroupMutation(c.config, OpUpdateOne, withGroup(gr)) + return &GroupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *GroupClient) UpdateOneID(id int) *GroupUpdateOne { + mutation := newGroupMutation(c.config, OpUpdateOne, withGroupID(id)) + return &GroupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for Group. +func (c *GroupClient) Delete() *GroupDelete { + mutation := newGroupMutation(c.config, OpDelete) + return &GroupDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *GroupClient) DeleteOne(gr *Group) *GroupDeleteOne { + return c.DeleteOneID(gr.ID) +} + +// DeleteOneID returns a builder for deleting the given entity by its id. +func (c *GroupClient) DeleteOneID(id int) *GroupDeleteOne { + builder := c.Delete().Where(group.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &GroupDeleteOne{builder} +} + +// Query returns a query builder for Group. +func (c *GroupClient) Query() *GroupQuery { + return &GroupQuery{ + config: c.config, + ctx: &QueryContext{Type: TypeGroup}, + inters: c.Interceptors(), + } +} + +// Get returns a Group entity by its id. +func (c *GroupClient) Get(ctx context.Context, id int) (*Group, error) { + return c.Query().Where(group.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *GroupClient) GetX(ctx context.Context, id int) *Group { + obj, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return obj +} + +// QueryUsers queries the users edge of a Group. +func (c *GroupClient) QueryUsers(gr *Group) *UserQuery { + query := (&UserClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := gr.ID + step := sqlgraph.NewStep( + sqlgraph.From(group.Table, group.FieldID, id), + sqlgraph.To(user.Table, user.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, group.UsersTable, group.UsersColumn), + ) + fromV = sqlgraph.Neighbors(gr.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// Hooks returns the client hooks. +func (c *GroupClient) Hooks() []Hook { + return c.hooks.Group +} + +// Interceptors returns the client interceptors. +func (c *GroupClient) Interceptors() []Interceptor { + return c.inters.Group +} + +func (c *GroupClient) mutate(ctx context.Context, m *GroupMutation) (Value, error) { + switch m.Op() { + case OpCreate: + return (&GroupCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdate: + return (&GroupUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdateOne: + return (&GroupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpDelete, OpDeleteOne: + return (&GroupDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx) + default: + return nil, fmt.Errorf("ent: unknown Group mutation op: %q", m.Op()) + } +} + +// UserClient is a client for the User schema. +type UserClient struct { + config +} + +// NewUserClient returns a client for the User from the given config. +func NewUserClient(c config) *UserClient { + return &UserClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `user.Hooks(f(g(h())))`. +func (c *UserClient) Use(hooks ...Hook) { + c.hooks.User = append(c.hooks.User, hooks...) +} + +// Intercept adds a list of query interceptors to the interceptors stack. +// A call to `Intercept(f, g, h)` equals to `user.Intercept(f(g(h())))`. +func (c *UserClient) Intercept(interceptors ...Interceptor) { + c.inters.User = append(c.inters.User, interceptors...) +} + +// Create returns a builder for creating a User entity. +func (c *UserClient) Create() *UserCreate { + mutation := newUserMutation(c.config, OpCreate) + return &UserCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of User entities. +func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { + return &UserCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for User. +func (c *UserClient) Update() *UserUpdate { + mutation := newUserMutation(c.config, OpUpdate) + return &UserUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *UserClient) UpdateOne(u *User) *UserUpdateOne { + mutation := newUserMutation(c.config, OpUpdateOne, withUser(u)) + return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *UserClient) UpdateOneID(id int) *UserUpdateOne { + mutation := newUserMutation(c.config, OpUpdateOne, withUserID(id)) + return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for User. +func (c *UserClient) Delete() *UserDelete { + mutation := newUserMutation(c.config, OpDelete) + return &UserDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *UserClient) DeleteOne(u *User) *UserDeleteOne { + return c.DeleteOneID(u.ID) +} + +// DeleteOneID returns a builder for deleting the given entity by its id. +func (c *UserClient) DeleteOneID(id int) *UserDeleteOne { + builder := c.Delete().Where(user.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &UserDeleteOne{builder} +} + +// Query returns a query builder for User. +func (c *UserClient) Query() *UserQuery { + return &UserQuery{ + config: c.config, + ctx: &QueryContext{Type: TypeUser}, + inters: c.Interceptors(), + } +} + +// Get returns a User entity by its id. +func (c *UserClient) Get(ctx context.Context, id int) (*User, error) { + return c.Query().Where(user.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *UserClient) GetX(ctx context.Context, id int) *User { + obj, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return obj +} + +// QueryCard queries the card edge of a User. +func (c *UserClient) QueryCard(u *User) *CardQuery { + query := (&CardClient{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(card.Table, card.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, user.CardTable, user.CardColumn), + ) + 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 +} + +// Interceptors returns the client interceptors. +func (c *UserClient) Interceptors() []Interceptor { + return c.inters.User +} + +func (c *UserClient) mutate(ctx context.Context, m *UserMutation) (Value, error) { + switch m.Op() { + case OpCreate: + return (&UserCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdate: + return (&UserUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdateOne: + return (&UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpDelete, OpDeleteOne: + return (&UserDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx) + default: + return nil, fmt.Errorf("ent: unknown User mutation op: %q", m.Op()) + } +} + +// hooks and interceptors per client, for fast access. +type ( + hooks struct { + Card, Group, User []ent.Hook + } + inters struct { + Card, Group, User []ent.Interceptor + } +) diff --git a/ent/config.go b/ent/config.go deleted file mode 100644 index 50fd3be..0000000 --- a/ent/config.go +++ /dev/null @@ -1,59 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package ent - -import ( - "entgo.io/ent" - "entgo.io/ent/dialect" -) - -// Option function to configure the client. -type Option func(*config) - -// Config is the configuration for the client and its builder. -type config struct { - // driver used for executing database requests. - driver dialect.Driver - // debug enable a debug logging. - debug bool - // log used for logging on debug mode. - log func(...interface{}) - // hooks to execute on mutations. - hooks *hooks -} - -// hooks per client, for fast access. -type hooks struct { - Users []ent.Hook -} - -// Options applies the options on the config object. -func (c *config) options(opts ...Option) { - for _, opt := range opts { - opt(c) - } - if c.debug { - c.driver = dialect.Debug(c.driver, c.log) - } -} - -// Debug enables debug logging on the ent.Driver. -func Debug() Option { - return func(c *config) { - c.debug = true - } -} - -// Log sets the logging function for debug mode. -func Log(fn func(...interface{})) Option { - return func(c *config) { - c.log = fn - } -} - -// Driver configures the client driver. -func Driver(driver dialect.Driver) Option { - return func(c *config) { - c.driver = driver - } -} diff --git a/ent/context.go b/ent/context.go deleted file mode 100644 index 0840726..0000000 --- a/ent/context.go +++ /dev/null @@ -1,33 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package ent - -import ( - "context" -) - -type clientCtxKey struct{} - -// FromContext returns a Client stored inside a context, or nil if there isn't one. -func FromContext(ctx context.Context) *Client { - c, _ := ctx.Value(clientCtxKey{}).(*Client) - return c -} - -// NewContext returns a new context with the given Client attached. -func NewContext(parent context.Context, c *Client) context.Context { - return context.WithValue(parent, clientCtxKey{}, c) -} - -type txCtxKey struct{} - -// TxFromContext returns a Tx stored inside a context, or nil if there isn't one. -func TxFromContext(ctx context.Context) *Tx { - tx, _ := ctx.Value(txCtxKey{}).(*Tx) - return tx -} - -// NewTxContext returns a new context with the given Tx attached. -func NewTxContext(parent context.Context, tx *Tx) context.Context { - return context.WithValue(parent, txCtxKey{}, tx) -} diff --git a/ent/ent.go b/ent/ent.go index 71f1693..381901a 100644 --- a/ent/ent.go +++ b/ent/ent.go @@ -1,35 +1,75 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package ent import ( + "context" "errors" "fmt" - "t/ent/users" + "reflect" + "t/ent/card" + "t/ent/group" + "t/ent/user" "entgo.io/ent" "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" ) // ent aliases to avoid import conflicts in user's code. type ( - Op = ent.Op - Hook = ent.Hook - Value = ent.Value - Query = ent.Query - Policy = ent.Policy - Mutator = ent.Mutator - Mutation = ent.Mutation - MutateFunc = ent.MutateFunc + Op = ent.Op + Hook = ent.Hook + Value = ent.Value + Query = ent.Query + QueryContext = ent.QueryContext + Querier = ent.Querier + QuerierFunc = ent.QuerierFunc + Interceptor = ent.Interceptor + InterceptFunc = ent.InterceptFunc + Traverser = ent.Traverser + TraverseFunc = ent.TraverseFunc + Policy = ent.Policy + Mutator = ent.Mutator + Mutation = ent.Mutation + MutateFunc = ent.MutateFunc ) +type clientCtxKey struct{} + +// FromContext returns a Client stored inside a context, or nil if there isn't one. +func FromContext(ctx context.Context) *Client { + c, _ := ctx.Value(clientCtxKey{}).(*Client) + return c +} + +// NewContext returns a new context with the given Client attached. +func NewContext(parent context.Context, c *Client) context.Context { + return context.WithValue(parent, clientCtxKey{}, c) +} + +type txCtxKey struct{} + +// TxFromContext returns a Tx stored inside a context, or nil if there isn't one. +func TxFromContext(ctx context.Context) *Tx { + tx, _ := ctx.Value(txCtxKey{}).(*Tx) + return tx +} + +// NewTxContext returns a new context with the given Tx attached. +func NewTxContext(parent context.Context, tx *Tx) context.Context { + return context.WithValue(parent, txCtxKey{}, tx) +} + // OrderFunc applies an ordering on the sql selector. type OrderFunc func(*sql.Selector) // columnChecker returns a function indicates if the column exists in the given column. func columnChecker(table string) func(string) error { checks := map[string]func(string) bool{ - users.Table: users.ValidColumn, + card.Table: card.ValidColumn, + group.Table: group.ValidColumn, + user.Table: user.ValidColumn, } check, ok := checks[table] if !ok { @@ -79,7 +119,6 @@ type AggregateFunc func(*sql.Selector) string // GroupBy(field1, field2). // Aggregate(ent.As(ent.Sum(field1), "sum_field1"), (ent.As(ent.Sum(field2), "sum_field2")). // Scan(ctx, &v) -// func As(fn AggregateFunc, end string) AggregateFunc { return func(s *sql.Selector) string { return sql.As(fn(s), end) @@ -257,3 +296,325 @@ func IsConstraintError(err error) bool { var e *ConstraintError return errors.As(err, &e) } + +// selector embedded by the different Select/GroupBy builders. +type selector struct { + label string + flds *[]string + fns []AggregateFunc + scan func(context.Context, any) error +} + +// ScanX is like Scan, but panics if an error occurs. +func (s *selector) ScanX(ctx context.Context, v any) { + if err := s.scan(ctx, v); err != nil { + panic(err) + } +} + +// Strings returns list of strings from a selector. It is only allowed when selecting one field. +func (s *selector) Strings(ctx context.Context) ([]string, error) { + if len(*s.flds) > 1 { + return nil, errors.New("ent: Strings is not achievable when selecting more than 1 field") + } + var v []string + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// StringsX is like Strings, but panics if an error occurs. +func (s *selector) StringsX(ctx context.Context) []string { + v, err := s.Strings(ctx) + if err != nil { + panic(err) + } + return v +} + +// String returns a single string from a selector. It is only allowed when selecting one field. +func (s *selector) String(ctx context.Context) (_ string, err error) { + var v []string + if v, err = s.Strings(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: Strings returned %d results when one was expected", len(v)) + } + return +} + +// StringX is like String, but panics if an error occurs. +func (s *selector) StringX(ctx context.Context) string { + v, err := s.String(ctx) + if err != nil { + panic(err) + } + return v +} + +// Ints returns list of ints from a selector. It is only allowed when selecting one field. +func (s *selector) Ints(ctx context.Context) ([]int, error) { + if len(*s.flds) > 1 { + return nil, errors.New("ent: Ints is not achievable when selecting more than 1 field") + } + var v []int + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// IntsX is like Ints, but panics if an error occurs. +func (s *selector) IntsX(ctx context.Context) []int { + v, err := s.Ints(ctx) + if err != nil { + panic(err) + } + return v +} + +// Int returns a single int from a selector. It is only allowed when selecting one field. +func (s *selector) Int(ctx context.Context) (_ int, err error) { + var v []int + if v, err = s.Ints(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: Ints returned %d results when one was expected", len(v)) + } + return +} + +// IntX is like Int, but panics if an error occurs. +func (s *selector) IntX(ctx context.Context) int { + v, err := s.Int(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. +func (s *selector) Float64s(ctx context.Context) ([]float64, error) { + if len(*s.flds) > 1 { + return nil, errors.New("ent: Float64s is not achievable when selecting more than 1 field") + } + var v []float64 + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// Float64sX is like Float64s, but panics if an error occurs. +func (s *selector) Float64sX(ctx context.Context) []float64 { + v, err := s.Float64s(ctx) + if err != nil { + panic(err) + } + return v +} + +// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. +func (s *selector) Float64(ctx context.Context) (_ float64, err error) { + var v []float64 + if v, err = s.Float64s(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: Float64s returned %d results when one was expected", len(v)) + } + return +} + +// Float64X is like Float64, but panics if an error occurs. +func (s *selector) Float64X(ctx context.Context) float64 { + v, err := s.Float64(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bools returns list of bools from a selector. It is only allowed when selecting one field. +func (s *selector) Bools(ctx context.Context) ([]bool, error) { + if len(*s.flds) > 1 { + return nil, errors.New("ent: Bools is not achievable when selecting more than 1 field") + } + var v []bool + if err := s.scan(ctx, &v); err != nil { + return nil, err + } + return v, nil +} + +// BoolsX is like Bools, but panics if an error occurs. +func (s *selector) BoolsX(ctx context.Context) []bool { + v, err := s.Bools(ctx) + if err != nil { + panic(err) + } + return v +} + +// Bool returns a single bool from a selector. It is only allowed when selecting one field. +func (s *selector) Bool(ctx context.Context) (_ bool, err error) { + var v []bool + if v, err = s.Bools(ctx); err != nil { + return + } + switch len(v) { + case 1: + return v[0], nil + case 0: + err = &NotFoundError{s.label} + default: + err = fmt.Errorf("ent: Bools returned %d results when one was expected", len(v)) + } + return +} + +// BoolX is like Bool, but panics if an error occurs. +func (s *selector) BoolX(ctx context.Context) bool { + v, err := s.Bool(ctx) + if err != nil { + panic(err) + } + return v +} + +// withHooks invokes the builder operation with the given hooks, if any. +func withHooks[V Value, M any, PM interface { + *M + Mutation +}](ctx context.Context, exec func(context.Context) (V, error), mutation PM, hooks []Hook) (value V, err error) { + if len(hooks) == 0 { + return exec(ctx) + } + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutationT, ok := m.(PM) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + // Set the mutation to the builder. + *mutation = *mutationT + return exec(ctx) + }) + for i := len(hooks) - 1; i >= 0; i-- { + if hooks[i] == nil { + return value, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)") + } + mut = hooks[i](mut) + } + v, err := mut.Mutate(ctx, mutation) + if err != nil { + return value, err + } + nv, ok := v.(V) + if !ok { + return value, fmt.Errorf("unexpected node type %T returned from %T", v, mutation) + } + return nv, nil +} + +// setContextOp returns a new context with the given QueryContext attached (including its op) in case it does not exist. +func setContextOp(ctx context.Context, qc *QueryContext, op string) context.Context { + if ent.QueryFromContext(ctx) == nil { + qc.Op = op + ctx = ent.NewQueryContext(ctx, qc) + } + return ctx +} + +func querierAll[V Value, Q interface { + sqlAll(context.Context, ...queryHook) (V, error) +}]() Querier { + return QuerierFunc(func(ctx context.Context, q Query) (Value, error) { + query, ok := q.(Q) + if !ok { + return nil, fmt.Errorf("unexpected query type %T", q) + } + return query.sqlAll(ctx) + }) +} + +func querierCount[Q interface { + sqlCount(context.Context) (int, error) +}]() Querier { + return QuerierFunc(func(ctx context.Context, q Query) (Value, error) { + query, ok := q.(Q) + if !ok { + return nil, fmt.Errorf("unexpected query type %T", q) + } + return query.sqlCount(ctx) + }) +} + +func withInterceptors[V Value](ctx context.Context, q Query, qr Querier, inters []Interceptor) (v V, err error) { + for i := len(inters) - 1; i >= 0; i-- { + qr = inters[i].Intercept(qr) + } + rv, err := qr.Query(ctx, q) + if err != nil { + return v, err + } + vt, ok := rv.(V) + if !ok { + return v, fmt.Errorf("unexpected type %T returned from %T. expected type: %T", vt, q, v) + } + return vt, nil +} + +func scanWithInterceptors[Q1 ent.Query, Q2 interface { + sqlScan(context.Context, Q1, any) error +}](ctx context.Context, rootQuery Q1, selectOrGroup Q2, inters []Interceptor, v any) error { + rv := reflect.ValueOf(v) + var qr Querier = QuerierFunc(func(ctx context.Context, q Query) (Value, error) { + query, ok := q.(Q1) + if !ok { + return nil, fmt.Errorf("unexpected query type %T", q) + } + if err := selectOrGroup.sqlScan(ctx, query, v); err != nil { + return nil, err + } + if k := rv.Kind(); k == reflect.Pointer && rv.Elem().CanInterface() { + return rv.Elem().Interface(), nil + } + return v, nil + }) + for i := len(inters) - 1; i >= 0; i-- { + qr = inters[i].Intercept(qr) + } + vv, err := qr.Query(ctx, rootQuery) + if err != nil { + return err + } + switch rv2 := reflect.ValueOf(vv); { + case rv.IsNil(), rv2.IsNil(), rv.Kind() != reflect.Pointer: + case rv.Type() == rv2.Type(): + rv.Elem().Set(rv2.Elem()) + case rv.Elem().Type() == rv2.Type(): + rv.Elem().Set(rv2) + } + return nil +} + +// queryHook describes an internal hook for the different sqlAll methods. +type queryHook func(context.Context, *sqlgraph.QuerySpec) diff --git a/ent/entc.go b/ent/entc.go index 225644e..258f844 100644 --- a/ent/entc.go +++ b/ent/entc.go @@ -5,13 +5,14 @@ package main import ( "log" + "ariga.io/ogent" "entgo.io/contrib/entoas" "entgo.io/ent/entc" "entgo.io/ent/entc/gen" - "github.com/ariga/ogent" "github.com/ogen-go/ogen" ) + func main() { spec := new(ogen.Spec) @@ -19,12 +20,12 @@ func main() { oas, err := entoas.NewExtension( entoas.Spec(spec), entoas.Mutations(func(_ *gen.Graph, spec *ogen.Spec) error { - spec.AddPathItem("/users/{id}/start", ogen.NewPathItem(). + spec.AddPathItem("/users/{id}/card/start", ogen.NewPathItem(). SetDescription("Start an draw as done"). SetPatch(ogen.NewOperation(). SetOperationID("drawStart"). SetSummary("Draws a card item as done."). - AddTags("Users"). + AddTags("Card"). AddResponse("204", ogen.NewResponse().SetDescription("Item marked as done")), ). AddParameters(ogen.NewParameter(). @@ -51,12 +52,12 @@ return nil // return nil // }), entoas.Mutations(func(_ *gen.Graph, spec *ogen.Spec) error { - spec.AddPathItem("/users/{id}/d", ogen.NewPathItem(). + spec.AddPathItem("/cards/{id}/d", ogen.NewPathItem(). SetDescription("Start an draw as done"). SetPut(ogen.NewOperation(). SetOperationID("drawDone"). SetSummary("Draws a card item as done."). - AddTags("Users"). + AddTags("Card"). AddResponse("204", ogen.NewResponse().SetDescription("Item marked as done")), //AddResponse("204", ogen.NewResponse().SetDescription("Item marked as done").SetSchema("test")), ). diff --git a/ent/enttest/enttest.go b/ent/enttest/enttest.go index e777ef9..9ddd3d3 100644 --- a/ent/enttest/enttest.go +++ b/ent/enttest/enttest.go @@ -1,4 +1,4 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package enttest @@ -8,6 +8,8 @@ import ( // required by schema hooks. _ "t/ent/runtime" + "t/ent/migrate" + "entgo.io/ent/dialect/sql/schema" ) @@ -16,7 +18,7 @@ type ( // testing.T and testing.B and used by enttest. TestingT interface { FailNow() - Error(...interface{}) + Error(...any) } // Option configures client creation. @@ -58,10 +60,7 @@ func Open(t TestingT, driverName, dataSourceName string, opts ...Option) *ent.Cl t.Error(err) t.FailNow() } - if err := c.Schema.Create(context.Background(), o.migrateOpts...); err != nil { - t.Error(err) - t.FailNow() - } + migrateSchema(t, c, o) return c } @@ -69,9 +68,17 @@ func Open(t TestingT, driverName, dataSourceName string, opts ...Option) *ent.Cl func NewClient(t TestingT, opts ...Option) *ent.Client { o := newOptions(opts) c := ent.NewClient(o.opts...) - if err := c.Schema.Create(context.Background(), o.migrateOpts...); err != nil { + migrateSchema(t, c, o) + return c +} +func migrateSchema(t TestingT, c *ent.Client, o *options) { + tables, err := schema.CopyTables(migrate.Tables) + if err != nil { + t.Error(err) + t.FailNow() + } + if err := migrate.Create(context.Background(), c.Schema, tables, o.migrateOpts...); err != nil { t.Error(err) t.FailNow() } - return c } diff --git a/ent/generate.go b/ent/generate.go index c6bc305..8232761 100644 --- a/ent/generate.go +++ b/ent/generate.go @@ -1,4 +1,3 @@ package ent //go:generate go run -mod=mod entc.go - diff --git a/ent/group.go b/ent/group.go new file mode 100644 index 0000000..e2a98f4 --- /dev/null +++ b/ent/group.go @@ -0,0 +1,119 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "fmt" + "strings" + "t/ent/group" + + "entgo.io/ent/dialect/sql" +) + +// Group is the model entity for the Group schema. +type Group struct { + config `json:"-"` + // ID of the ent. + ID int `json:"id,omitempty"` + // Name holds the value of the "name" field. + Name string `json:"name,omitempty"` + // Edges holds the relations/edges for other nodes in the graph. + // The values are being populated by the GroupQuery when eager-loading is set. + Edges GroupEdges `json:"edges"` +} + +// GroupEdges holds the relations/edges for other nodes in the graph. +type GroupEdges struct { + // Users holds the value of the users edge. + Users []*User `json:"users,omitempty"` + // loadedTypes holds the information for reporting if a + // type was loaded (or requested) in eager-loading or not. + loadedTypes [1]bool +} + +// UsersOrErr returns the Users value or an error if the edge +// was not loaded in eager-loading. +func (e GroupEdges) UsersOrErr() ([]*User, error) { + if e.loadedTypes[0] { + return e.Users, nil + } + return nil, &NotLoadedError{edge: "users"} +} + +// scanValues returns the types for scanning values from sql.Rows. +func (*Group) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case group.FieldID: + values[i] = new(sql.NullInt64) + case group.FieldName: + values[i] = new(sql.NullString) + default: + return nil, fmt.Errorf("unexpected column %q for type Group", columns[i]) + } + } + return values, nil +} + +// assignValues assigns the values that were returned from sql.Rows (after scanning) +// to the Group fields. +func (gr *Group) 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 group.FieldID: + value, ok := values[i].(*sql.NullInt64) + if !ok { + return fmt.Errorf("unexpected type %T for field id", value) + } + gr.ID = int(value.Int64) + case group.FieldName: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field name", values[i]) + } else if value.Valid { + gr.Name = value.String + } + } + } + return nil +} + +// QueryUsers queries the "users" edge of the Group entity. +func (gr *Group) QueryUsers() *UserQuery { + return NewGroupClient(gr.config).QueryUsers(gr) +} + +// Update returns a builder for updating this Group. +// Note that you need to call Group.Unwrap() before calling this method if this Group +// was returned from a transaction, and the transaction was committed or rolled back. +func (gr *Group) Update() *GroupUpdateOne { + return NewGroupClient(gr.config).UpdateOne(gr) +} + +// Unwrap unwraps the Group 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 (gr *Group) Unwrap() *Group { + _tx, ok := gr.config.driver.(*txDriver) + if !ok { + panic("ent: Group is not a transactional entity") + } + gr.config.driver = _tx.drv + return gr +} + +// String implements the fmt.Stringer. +func (gr *Group) String() string { + var builder strings.Builder + builder.WriteString("Group(") + builder.WriteString(fmt.Sprintf("id=%v, ", gr.ID)) + builder.WriteString("name=") + builder.WriteString(gr.Name) + builder.WriteByte(')') + return builder.String() +} + +// Groups is a parsable slice of Group. +type Groups []*Group diff --git a/ent/group/group.go b/ent/group/group.go new file mode 100644 index 0000000..0318cb8 --- /dev/null +++ b/ent/group/group.go @@ -0,0 +1,39 @@ +// Code generated by ent, DO NOT EDIT. + +package group + +const ( + // Label holds the string label denoting the group type in the database. + Label = "group" + // FieldID holds the string denoting the id field in the database. + FieldID = "id" + // FieldName holds the string denoting the name field in the database. + FieldName = "name" + // EdgeUsers holds the string denoting the users edge name in mutations. + EdgeUsers = "users" + // Table holds the table name of the group in the database. + Table = "groups" + // UsersTable is the table that holds the users relation/edge. + UsersTable = "users" + // UsersInverseTable is the table name for the User entity. + // It exists in this package in order to avoid circular dependency with the "user" package. + UsersInverseTable = "users" + // UsersColumn is the table column denoting the users relation/edge. + UsersColumn = "group_users" +) + +// Columns holds all SQL columns for group fields. +var Columns = []string{ + FieldID, + FieldName, +} + +// ValidColumn reports if the column name is valid (part of the table columns). +func ValidColumn(column string) bool { + for i := range Columns { + if column == Columns[i] { + return true + } + } + return false +} diff --git a/ent/group/where.go b/ent/group/where.go new file mode 100644 index 0000000..1f73737 --- /dev/null +++ b/ent/group/where.go @@ -0,0 +1,184 @@ +// Code generated by ent, DO NOT EDIT. + +package group + +import ( + "t/ent/predicate" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" +) + +// ID filters vertices based on their ID field. +func ID(id int) predicate.Group { + return predicate.Group(sql.FieldEQ(FieldID, id)) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id int) predicate.Group { + return predicate.Group(sql.FieldEQ(FieldID, id)) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id int) predicate.Group { + return predicate.Group(sql.FieldNEQ(FieldID, id)) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...int) predicate.Group { + return predicate.Group(sql.FieldIn(FieldID, ids...)) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...int) predicate.Group { + return predicate.Group(sql.FieldNotIn(FieldID, ids...)) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id int) predicate.Group { + return predicate.Group(sql.FieldGT(FieldID, id)) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id int) predicate.Group { + return predicate.Group(sql.FieldGTE(FieldID, id)) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id int) predicate.Group { + return predicate.Group(sql.FieldLT(FieldID, id)) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id int) predicate.Group { + return predicate.Group(sql.FieldLTE(FieldID, id)) +} + +// Name applies equality check predicate on the "name" field. It's identical to NameEQ. +func Name(v string) predicate.Group { + return predicate.Group(sql.FieldEQ(FieldName, v)) +} + +// NameEQ applies the EQ predicate on the "name" field. +func NameEQ(v string) predicate.Group { + return predicate.Group(sql.FieldEQ(FieldName, v)) +} + +// NameNEQ applies the NEQ predicate on the "name" field. +func NameNEQ(v string) predicate.Group { + return predicate.Group(sql.FieldNEQ(FieldName, v)) +} + +// NameIn applies the In predicate on the "name" field. +func NameIn(vs ...string) predicate.Group { + return predicate.Group(sql.FieldIn(FieldName, vs...)) +} + +// NameNotIn applies the NotIn predicate on the "name" field. +func NameNotIn(vs ...string) predicate.Group { + return predicate.Group(sql.FieldNotIn(FieldName, vs...)) +} + +// NameGT applies the GT predicate on the "name" field. +func NameGT(v string) predicate.Group { + return predicate.Group(sql.FieldGT(FieldName, v)) +} + +// NameGTE applies the GTE predicate on the "name" field. +func NameGTE(v string) predicate.Group { + return predicate.Group(sql.FieldGTE(FieldName, v)) +} + +// NameLT applies the LT predicate on the "name" field. +func NameLT(v string) predicate.Group { + return predicate.Group(sql.FieldLT(FieldName, v)) +} + +// NameLTE applies the LTE predicate on the "name" field. +func NameLTE(v string) predicate.Group { + return predicate.Group(sql.FieldLTE(FieldName, v)) +} + +// NameContains applies the Contains predicate on the "name" field. +func NameContains(v string) predicate.Group { + return predicate.Group(sql.FieldContains(FieldName, v)) +} + +// NameHasPrefix applies the HasPrefix predicate on the "name" field. +func NameHasPrefix(v string) predicate.Group { + return predicate.Group(sql.FieldHasPrefix(FieldName, v)) +} + +// NameHasSuffix applies the HasSuffix predicate on the "name" field. +func NameHasSuffix(v string) predicate.Group { + return predicate.Group(sql.FieldHasSuffix(FieldName, v)) +} + +// NameEqualFold applies the EqualFold predicate on the "name" field. +func NameEqualFold(v string) predicate.Group { + return predicate.Group(sql.FieldEqualFold(FieldName, v)) +} + +// NameContainsFold applies the ContainsFold predicate on the "name" field. +func NameContainsFold(v string) predicate.Group { + return predicate.Group(sql.FieldContainsFold(FieldName, v)) +} + +// HasUsers applies the HasEdge predicate on the "users" edge. +func HasUsers() predicate.Group { + return predicate.Group(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, UsersTable, UsersColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasUsersWith applies the HasEdge predicate on the "users" edge with a given conditions (other predicates). +func HasUsersWith(preds ...predicate.User) predicate.Group { + return predicate.Group(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(UsersInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, UsersTable, UsersColumn), + ) + 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.Group) predicate.Group { + return predicate.Group(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.Group) predicate.Group { + return predicate.Group(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.Group) predicate.Group { + return predicate.Group(func(s *sql.Selector) { + p(s.Not()) + }) +} diff --git a/ent/group_create.go b/ent/group_create.go new file mode 100644 index 0000000..e150d67 --- /dev/null +++ b/ent/group_create.go @@ -0,0 +1,214 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "t/ent/group" + "t/ent/user" + + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// GroupCreate is the builder for creating a Group entity. +type GroupCreate struct { + config + mutation *GroupMutation + hooks []Hook +} + +// SetName sets the "name" field. +func (gc *GroupCreate) SetName(s string) *GroupCreate { + gc.mutation.SetName(s) + return gc +} + +// AddUserIDs adds the "users" edge to the User entity by IDs. +func (gc *GroupCreate) AddUserIDs(ids ...int) *GroupCreate { + gc.mutation.AddUserIDs(ids...) + return gc +} + +// AddUsers adds the "users" edges to the User entity. +func (gc *GroupCreate) AddUsers(u ...*User) *GroupCreate { + ids := make([]int, len(u)) + for i := range u { + ids[i] = u[i].ID + } + return gc.AddUserIDs(ids...) +} + +// Mutation returns the GroupMutation object of the builder. +func (gc *GroupCreate) Mutation() *GroupMutation { + return gc.mutation +} + +// Save creates the Group in the database. +func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) { + return withHooks[*Group, GroupMutation](ctx, gc.sqlSave, gc.mutation, gc.hooks) +} + +// SaveX calls Save and panics if Save returns an error. +func (gc *GroupCreate) SaveX(ctx context.Context) *Group { + v, err := gc.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (gc *GroupCreate) Exec(ctx context.Context) error { + _, err := gc.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (gc *GroupCreate) ExecX(ctx context.Context) { + if err := gc.Exec(ctx); err != nil { + panic(err) + } +} + +// check runs all checks and user-defined validators on the builder. +func (gc *GroupCreate) check() error { + if _, ok := gc.mutation.Name(); !ok { + return &ValidationError{Name: "name", err: errors.New(`ent: missing required field "Group.name"`)} + } + return nil +} + +func (gc *GroupCreate) sqlSave(ctx context.Context) (*Group, error) { + if err := gc.check(); err != nil { + return nil, err + } + _node, _spec := gc.createSpec() + if err := sqlgraph.CreateNode(ctx, gc.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) + gc.mutation.id = &_node.ID + gc.mutation.done = true + return _node, nil +} + +func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) { + var ( + _node = &Group{config: gc.config} + _spec = sqlgraph.NewCreateSpec(group.Table, sqlgraph.NewFieldSpec(group.FieldID, field.TypeInt)) + ) + if value, ok := gc.mutation.Name(); ok { + _spec.SetField(group.FieldName, field.TypeString, value) + _node.Name = value + } + if nodes := gc.mutation.UsersIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.UsersTable, + Columns: []string{group.UsersColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } + return _node, _spec +} + +// GroupCreateBulk is the builder for creating many Group entities in bulk. +type GroupCreateBulk struct { + config + builders []*GroupCreate +} + +// Save creates the Group entities in the database. +func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) + nodes := make([]*Group, len(gcb.builders)) + mutators := make([]Mutator, len(gcb.builders)) + for i := range gcb.builders { + func(i int, root context.Context) { + builder := gcb.builders[i] + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*GroupMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + nodes[i], specs[i] = builder.createSpec() + var err error + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, gcb.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, gcb.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, gcb.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (gcb *GroupCreateBulk) SaveX(ctx context.Context) []*Group { + v, err := gcb.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (gcb *GroupCreateBulk) Exec(ctx context.Context) error { + _, err := gcb.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (gcb *GroupCreateBulk) ExecX(ctx context.Context) { + if err := gcb.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/ent/group_delete.go b/ent/group_delete.go new file mode 100644 index 0000000..10161fa --- /dev/null +++ b/ent/group_delete.go @@ -0,0 +1,88 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "t/ent/group" + "t/ent/predicate" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// GroupDelete is the builder for deleting a Group entity. +type GroupDelete struct { + config + hooks []Hook + mutation *GroupMutation +} + +// Where appends a list predicates to the GroupDelete builder. +func (gd *GroupDelete) Where(ps ...predicate.Group) *GroupDelete { + gd.mutation.Where(ps...) + return gd +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (gd *GroupDelete) Exec(ctx context.Context) (int, error) { + return withHooks[int, GroupMutation](ctx, gd.sqlExec, gd.mutation, gd.hooks) +} + +// ExecX is like Exec, but panics if an error occurs. +func (gd *GroupDelete) ExecX(ctx context.Context) int { + n, err := gd.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +func (gd *GroupDelete) sqlExec(ctx context.Context) (int, error) { + _spec := sqlgraph.NewDeleteSpec(group.Table, sqlgraph.NewFieldSpec(group.FieldID, field.TypeInt)) + if ps := gd.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, gd.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + gd.mutation.done = true + return affected, err +} + +// GroupDeleteOne is the builder for deleting a single Group entity. +type GroupDeleteOne struct { + gd *GroupDelete +} + +// Where appends a list predicates to the GroupDelete builder. +func (gdo *GroupDeleteOne) Where(ps ...predicate.Group) *GroupDeleteOne { + gdo.gd.mutation.Where(ps...) + return gdo +} + +// Exec executes the deletion query. +func (gdo *GroupDeleteOne) Exec(ctx context.Context) error { + n, err := gdo.gd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{group.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (gdo *GroupDeleteOne) ExecX(ctx context.Context) { + if err := gdo.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/ent/group_query.go b/ent/group_query.go new file mode 100644 index 0000000..7f3b189 --- /dev/null +++ b/ent/group_query.go @@ -0,0 +1,606 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "database/sql/driver" + "fmt" + "math" + "t/ent/group" + "t/ent/predicate" + "t/ent/user" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// GroupQuery is the builder for querying Group entities. +type GroupQuery struct { + config + ctx *QueryContext + order []OrderFunc + inters []Interceptor + predicates []predicate.Group + withUsers *UserQuery + // intermediate query (i.e. traversal path). + sql *sql.Selector + path func(context.Context) (*sql.Selector, error) +} + +// Where adds a new predicate for the GroupQuery builder. +func (gq *GroupQuery) Where(ps ...predicate.Group) *GroupQuery { + gq.predicates = append(gq.predicates, ps...) + return gq +} + +// Limit the number of records to be returned by this query. +func (gq *GroupQuery) Limit(limit int) *GroupQuery { + gq.ctx.Limit = &limit + return gq +} + +// Offset to start from. +func (gq *GroupQuery) Offset(offset int) *GroupQuery { + gq.ctx.Offset = &offset + return gq +} + +// 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 (gq *GroupQuery) Unique(unique bool) *GroupQuery { + gq.ctx.Unique = &unique + return gq +} + +// Order specifies how the records should be ordered. +func (gq *GroupQuery) Order(o ...OrderFunc) *GroupQuery { + gq.order = append(gq.order, o...) + return gq +} + +// QueryUsers chains the current query on the "users" edge. +func (gq *GroupQuery) QueryUsers() *UserQuery { + query := (&UserClient{config: gq.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := gq.prepareQuery(ctx); err != nil { + return nil, err + } + selector := gq.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(group.Table, group.FieldID, selector), + sqlgraph.To(user.Table, user.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, group.UsersTable, group.UsersColumn), + ) + fromU = sqlgraph.SetNeighbors(gq.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// First returns the first Group entity from the query. +// Returns a *NotFoundError when no Group was found. +func (gq *GroupQuery) First(ctx context.Context) (*Group, error) { + nodes, err := gq.Limit(1).All(setContextOp(ctx, gq.ctx, "First")) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{group.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (gq *GroupQuery) FirstX(ctx context.Context) *Group { + node, err := gq.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first Group ID from the query. +// Returns a *NotFoundError when no Group ID was found. +func (gq *GroupQuery) FirstID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = gq.Limit(1).IDs(setContextOp(ctx, gq.ctx, "FirstID")); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{group.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (gq *GroupQuery) FirstIDX(ctx context.Context) int { + id, err := gq.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single Group entity found by the query, ensuring it only returns one. +// Returns a *NotSingularError when more than one Group entity is found. +// Returns a *NotFoundError when no Group entities are found. +func (gq *GroupQuery) Only(ctx context.Context) (*Group, error) { + nodes, err := gq.Limit(2).All(setContextOp(ctx, gq.ctx, "Only")) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{group.Label} + default: + return nil, &NotSingularError{group.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (gq *GroupQuery) OnlyX(ctx context.Context) *Group { + node, err := gq.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only Group ID in the query. +// Returns a *NotSingularError when more than one Group ID is found. +// Returns a *NotFoundError when no entities are found. +func (gq *GroupQuery) OnlyID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = gq.Limit(2).IDs(setContextOp(ctx, gq.ctx, "OnlyID")); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{group.Label} + default: + err = &NotSingularError{group.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (gq *GroupQuery) OnlyIDX(ctx context.Context) int { + id, err := gq.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of Groups. +func (gq *GroupQuery) All(ctx context.Context) ([]*Group, error) { + ctx = setContextOp(ctx, gq.ctx, "All") + if err := gq.prepareQuery(ctx); err != nil { + return nil, err + } + qr := querierAll[[]*Group, *GroupQuery]() + return withInterceptors[[]*Group](ctx, gq, qr, gq.inters) +} + +// AllX is like All, but panics if an error occurs. +func (gq *GroupQuery) AllX(ctx context.Context) []*Group { + nodes, err := gq.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// IDs executes the query and returns a list of Group IDs. +func (gq *GroupQuery) IDs(ctx context.Context) (ids []int, err error) { + if gq.ctx.Unique == nil && gq.path != nil { + gq.Unique(true) + } + ctx = setContextOp(ctx, gq.ctx, "IDs") + if err = gq.Select(group.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (gq *GroupQuery) IDsX(ctx context.Context) []int { + ids, err := gq.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (gq *GroupQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, gq.ctx, "Count") + if err := gq.prepareQuery(ctx); err != nil { + return 0, err + } + return withInterceptors[int](ctx, gq, querierCount[*GroupQuery](), gq.inters) +} + +// CountX is like Count, but panics if an error occurs. +func (gq *GroupQuery) CountX(ctx context.Context) int { + count, err := gq.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (gq *GroupQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, gq.ctx, "Exist") + switch _, err := gq.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 (gq *GroupQuery) ExistX(ctx context.Context) bool { + exist, err := gq.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the GroupQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (gq *GroupQuery) Clone() *GroupQuery { + if gq == nil { + return nil + } + return &GroupQuery{ + config: gq.config, + ctx: gq.ctx.Clone(), + order: append([]OrderFunc{}, gq.order...), + inters: append([]Interceptor{}, gq.inters...), + predicates: append([]predicate.Group{}, gq.predicates...), + withUsers: gq.withUsers.Clone(), + // clone intermediate query. + sql: gq.sql.Clone(), + path: gq.path, + } +} + +// WithUsers tells the query-builder to eager-load the nodes that are connected to +// the "users" edge. The optional arguments are used to configure the query builder of the edge. +func (gq *GroupQuery) WithUsers(opts ...func(*UserQuery)) *GroupQuery { + query := (&UserClient{config: gq.config}).Query() + for _, opt := range opts { + opt(query) + } + gq.withUsers = query + return gq +} + +// GroupBy is used to group vertices by one or more fields/columns. +// It is often used with aggregate functions, like: count, max, mean, min, sum. +// +// Example: +// +// var v []struct { +// Name string `json:"name,omitempty"` +// Count int `json:"count,omitempty"` +// } +// +// client.Group.Query(). +// GroupBy(group.FieldName). +// Aggregate(ent.Count()). +// Scan(ctx, &v) +func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy { + gq.ctx.Fields = append([]string{field}, fields...) + grbuild := &GroupGroupBy{build: gq} + grbuild.flds = &gq.ctx.Fields + grbuild.label = group.Label + grbuild.scan = grbuild.Scan + return grbuild +} + +// Select allows the selection one or more fields/columns for the given query, +// instead of selecting all fields in the entity. +// +// Example: +// +// var v []struct { +// Name string `json:"name,omitempty"` +// } +// +// client.Group.Query(). +// Select(group.FieldName). +// Scan(ctx, &v) +func (gq *GroupQuery) Select(fields ...string) *GroupSelect { + gq.ctx.Fields = append(gq.ctx.Fields, fields...) + sbuild := &GroupSelect{GroupQuery: gq} + sbuild.label = group.Label + sbuild.flds, sbuild.scan = &gq.ctx.Fields, sbuild.Scan + return sbuild +} + +// Aggregate returns a GroupSelect configured with the given aggregations. +func (gq *GroupQuery) Aggregate(fns ...AggregateFunc) *GroupSelect { + return gq.Select().Aggregate(fns...) +} + +func (gq *GroupQuery) prepareQuery(ctx context.Context) error { + for _, inter := range gq.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, gq); err != nil { + return err + } + } + } + for _, f := range gq.ctx.Fields { + if !group.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + } + if gq.path != nil { + prev, err := gq.path(ctx) + if err != nil { + return err + } + gq.sql = prev + } + return nil +} + +func (gq *GroupQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Group, error) { + var ( + nodes = []*Group{} + _spec = gq.querySpec() + loadedTypes = [1]bool{ + gq.withUsers != nil, + } + ) + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*Group).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &Group{config: gq.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, gq.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + if query := gq.withUsers; query != nil { + if err := gq.loadUsers(ctx, query, nodes, + func(n *Group) { n.Edges.Users = []*User{} }, + func(n *Group, e *User) { n.Edges.Users = append(n.Edges.Users, e) }); err != nil { + return nil, err + } + } + return nodes, nil +} + +func (gq *GroupQuery) loadUsers(ctx context.Context, query *UserQuery, nodes []*Group, init func(*Group), assign func(*Group, *User)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[int]*Group) + 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.User(func(s *sql.Selector) { + s.Where(sql.InValues(group.UsersColumn, fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.group_users + if fk == nil { + return fmt.Errorf(`foreign-key "group_users" is nil for node %v`, n.ID) + } + node, ok := nodeids[*fk] + if !ok { + return fmt.Errorf(`unexpected foreign-key "group_users" returned %v for node %v`, *fk, n.ID) + } + assign(node, n) + } + return nil +} + +func (gq *GroupQuery) sqlCount(ctx context.Context) (int, error) { + _spec := gq.querySpec() + _spec.Node.Columns = gq.ctx.Fields + if len(gq.ctx.Fields) > 0 { + _spec.Unique = gq.ctx.Unique != nil && *gq.ctx.Unique + } + return sqlgraph.CountNodes(ctx, gq.driver, _spec) +} + +func (gq *GroupQuery) querySpec() *sqlgraph.QuerySpec { + _spec := sqlgraph.NewQuerySpec(group.Table, group.Columns, sqlgraph.NewFieldSpec(group.FieldID, field.TypeInt)) + _spec.From = gq.sql + if unique := gq.ctx.Unique; unique != nil { + _spec.Unique = *unique + } else if gq.path != nil { + _spec.Unique = true + } + if fields := gq.ctx.Fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, group.FieldID) + for i := range fields { + if fields[i] != group.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + } + if ps := gq.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := gq.ctx.Limit; limit != nil { + _spec.Limit = *limit + } + if offset := gq.ctx.Offset; offset != nil { + _spec.Offset = *offset + } + if ps := gq.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (gq *GroupQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(gq.driver.Dialect()) + t1 := builder.Table(group.Table) + columns := gq.ctx.Fields + if len(columns) == 0 { + columns = group.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if gq.sql != nil { + selector = gq.sql + selector.Select(selector.Columns(columns...)...) + } + if gq.ctx.Unique != nil && *gq.ctx.Unique { + selector.Distinct() + } + for _, p := range gq.predicates { + p(selector) + } + for _, p := range gq.order { + p(selector) + } + if offset := gq.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 := gq.ctx.Limit; limit != nil { + selector.Limit(*limit) + } + return selector +} + +// GroupGroupBy is the group-by builder for Group entities. +type GroupGroupBy struct { + selector + build *GroupQuery +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (ggb *GroupGroupBy) Aggregate(fns ...AggregateFunc) *GroupGroupBy { + ggb.fns = append(ggb.fns, fns...) + return ggb +} + +// Scan applies the selector query and scans the result into the given value. +func (ggb *GroupGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, ggb.build.ctx, "GroupBy") + if err := ggb.build.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*GroupQuery, *GroupGroupBy](ctx, ggb.build, ggb, ggb.build.inters, v) +} + +func (ggb *GroupGroupBy) sqlScan(ctx context.Context, root *GroupQuery, v any) error { + selector := root.sqlQuery(ctx).Select() + aggregation := make([]string, 0, len(ggb.fns)) + for _, fn := range ggb.fns { + aggregation = append(aggregation, fn(selector)) + } + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(*ggb.flds)+len(ggb.fns)) + for _, f := range *ggb.flds { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + selector.GroupBy(selector.Columns(*ggb.flds...)...) + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := ggb.build.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// GroupSelect is the builder for selecting fields of Group entities. +type GroupSelect struct { + *GroupQuery + selector +} + +// Aggregate adds the given aggregation functions to the selector query. +func (gs *GroupSelect) Aggregate(fns ...AggregateFunc) *GroupSelect { + gs.fns = append(gs.fns, fns...) + return gs +} + +// Scan applies the selector query and scans the result into the given value. +func (gs *GroupSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, gs.ctx, "Select") + if err := gs.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*GroupQuery, *GroupSelect](ctx, gs.GroupQuery, gs, gs.inters, v) +} + +func (gs *GroupSelect) sqlScan(ctx context.Context, root *GroupQuery, v any) error { + selector := root.sqlQuery(ctx) + aggregation := make([]string, 0, len(gs.fns)) + for _, fn := range gs.fns { + aggregation = append(aggregation, fn(selector)) + } + switch n := len(*gs.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 := gs.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} diff --git a/ent/group_update.go b/ent/group_update.go new file mode 100644 index 0000000..1910926 --- /dev/null +++ b/ent/group_update.go @@ -0,0 +1,374 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "t/ent/group" + "t/ent/predicate" + "t/ent/user" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// GroupUpdate is the builder for updating Group entities. +type GroupUpdate struct { + config + hooks []Hook + mutation *GroupMutation +} + +// Where appends a list predicates to the GroupUpdate builder. +func (gu *GroupUpdate) Where(ps ...predicate.Group) *GroupUpdate { + gu.mutation.Where(ps...) + return gu +} + +// SetName sets the "name" field. +func (gu *GroupUpdate) SetName(s string) *GroupUpdate { + gu.mutation.SetName(s) + return gu +} + +// AddUserIDs adds the "users" edge to the User entity by IDs. +func (gu *GroupUpdate) AddUserIDs(ids ...int) *GroupUpdate { + gu.mutation.AddUserIDs(ids...) + return gu +} + +// AddUsers adds the "users" edges to the User entity. +func (gu *GroupUpdate) AddUsers(u ...*User) *GroupUpdate { + ids := make([]int, len(u)) + for i := range u { + ids[i] = u[i].ID + } + return gu.AddUserIDs(ids...) +} + +// Mutation returns the GroupMutation object of the builder. +func (gu *GroupUpdate) Mutation() *GroupMutation { + return gu.mutation +} + +// ClearUsers clears all "users" edges to the User entity. +func (gu *GroupUpdate) ClearUsers() *GroupUpdate { + gu.mutation.ClearUsers() + return gu +} + +// RemoveUserIDs removes the "users" edge to User entities by IDs. +func (gu *GroupUpdate) RemoveUserIDs(ids ...int) *GroupUpdate { + gu.mutation.RemoveUserIDs(ids...) + return gu +} + +// RemoveUsers removes "users" edges to User entities. +func (gu *GroupUpdate) RemoveUsers(u ...*User) *GroupUpdate { + ids := make([]int, len(u)) + for i := range u { + ids[i] = u[i].ID + } + return gu.RemoveUserIDs(ids...) +} + +// Save executes the query and returns the number of nodes affected by the update operation. +func (gu *GroupUpdate) Save(ctx context.Context) (int, error) { + return withHooks[int, GroupMutation](ctx, gu.sqlSave, gu.mutation, gu.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (gu *GroupUpdate) SaveX(ctx context.Context) int { + affected, err := gu.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (gu *GroupUpdate) Exec(ctx context.Context) error { + _, err := gu.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (gu *GroupUpdate) ExecX(ctx context.Context) { + if err := gu.Exec(ctx); err != nil { + panic(err) + } +} + +func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) { + _spec := sqlgraph.NewUpdateSpec(group.Table, group.Columns, sqlgraph.NewFieldSpec(group.FieldID, field.TypeInt)) + if ps := gu.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := gu.mutation.Name(); ok { + _spec.SetField(group.FieldName, field.TypeString, value) + } + if gu.mutation.UsersCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.UsersTable, + Columns: []string{group.UsersColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := gu.mutation.RemovedUsersIDs(); len(nodes) > 0 && !gu.mutation.UsersCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.UsersTable, + Columns: []string{group.UsersColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := gu.mutation.UsersIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.UsersTable, + Columns: []string{group.UsersColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + 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, gu.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{group.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + gu.mutation.done = true + return n, nil +} + +// GroupUpdateOne is the builder for updating a single Group entity. +type GroupUpdateOne struct { + config + fields []string + hooks []Hook + mutation *GroupMutation +} + +// SetName sets the "name" field. +func (guo *GroupUpdateOne) SetName(s string) *GroupUpdateOne { + guo.mutation.SetName(s) + return guo +} + +// AddUserIDs adds the "users" edge to the User entity by IDs. +func (guo *GroupUpdateOne) AddUserIDs(ids ...int) *GroupUpdateOne { + guo.mutation.AddUserIDs(ids...) + return guo +} + +// AddUsers adds the "users" edges to the User entity. +func (guo *GroupUpdateOne) AddUsers(u ...*User) *GroupUpdateOne { + ids := make([]int, len(u)) + for i := range u { + ids[i] = u[i].ID + } + return guo.AddUserIDs(ids...) +} + +// Mutation returns the GroupMutation object of the builder. +func (guo *GroupUpdateOne) Mutation() *GroupMutation { + return guo.mutation +} + +// ClearUsers clears all "users" edges to the User entity. +func (guo *GroupUpdateOne) ClearUsers() *GroupUpdateOne { + guo.mutation.ClearUsers() + return guo +} + +// RemoveUserIDs removes the "users" edge to User entities by IDs. +func (guo *GroupUpdateOne) RemoveUserIDs(ids ...int) *GroupUpdateOne { + guo.mutation.RemoveUserIDs(ids...) + return guo +} + +// RemoveUsers removes "users" edges to User entities. +func (guo *GroupUpdateOne) RemoveUsers(u ...*User) *GroupUpdateOne { + ids := make([]int, len(u)) + for i := range u { + ids[i] = u[i].ID + } + return guo.RemoveUserIDs(ids...) +} + +// Where appends a list predicates to the GroupUpdate builder. +func (guo *GroupUpdateOne) Where(ps ...predicate.Group) *GroupUpdateOne { + guo.mutation.Where(ps...) + return guo +} + +// Select allows selecting one or more fields (columns) of the returned entity. +// The default is selecting all fields defined in the entity schema. +func (guo *GroupUpdateOne) Select(field string, fields ...string) *GroupUpdateOne { + guo.fields = append([]string{field}, fields...) + return guo +} + +// Save executes the query and returns the updated Group entity. +func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) { + return withHooks[*Group, GroupMutation](ctx, guo.sqlSave, guo.mutation, guo.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (guo *GroupUpdateOne) SaveX(ctx context.Context) *Group { + node, err := guo.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (guo *GroupUpdateOne) Exec(ctx context.Context) error { + _, err := guo.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (guo *GroupUpdateOne) ExecX(ctx context.Context) { + if err := guo.Exec(ctx); err != nil { + panic(err) + } +} + +func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error) { + _spec := sqlgraph.NewUpdateSpec(group.Table, group.Columns, sqlgraph.NewFieldSpec(group.FieldID, field.TypeInt)) + id, ok := guo.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Group.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := guo.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, group.FieldID) + for _, f := range fields { + if !group.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + if f != group.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := guo.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := guo.mutation.Name(); ok { + _spec.SetField(group.FieldName, field.TypeString, value) + } + if guo.mutation.UsersCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.UsersTable, + Columns: []string{group.UsersColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := guo.mutation.RemovedUsersIDs(); len(nodes) > 0 && !guo.mutation.UsersCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.UsersTable, + Columns: []string{group.UsersColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := guo.mutation.UsersIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.UsersTable, + Columns: []string{group.UsersColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: user.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + _node = &Group{config: guo.config} + _spec.Assign = _node.assignValues + _spec.ScanValues = _node.scanValues + if err = sqlgraph.UpdateNode(ctx, guo.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{group.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + guo.mutation.done = true + return _node, nil +} diff --git a/ent/hook/hook.go b/ent/hook/hook.go index d50076d..f3f88fd 100644 --- a/ent/hook/hook.go +++ b/ent/hook/hook.go @@ -1,4 +1,4 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package hook @@ -8,17 +8,40 @@ import ( "t/ent" ) -// The UsersFunc type is an adapter to allow the use of ordinary -// function as Users mutator. -type UsersFunc func(context.Context, *ent.UsersMutation) (ent.Value, error) +// The CardFunc type is an adapter to allow the use of ordinary +// function as Card mutator. +type CardFunc func(context.Context, *ent.CardMutation) (ent.Value, error) // Mutate calls f(ctx, m). -func (f UsersFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { - mv, ok := m.(*ent.UsersMutation) - if !ok { - return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UsersMutation", m) +func (f CardFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { + if mv, ok := m.(*ent.CardMutation); ok { + return f(ctx, mv) } - return f(ctx, mv) + return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.CardMutation", m) +} + +// The GroupFunc type is an adapter to allow the use of ordinary +// function as Group mutator. +type GroupFunc func(context.Context, *ent.GroupMutation) (ent.Value, error) + +// Mutate calls f(ctx, m). +func (f GroupFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { + if mv, ok := m.(*ent.GroupMutation); ok { + return f(ctx, mv) + } + return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.GroupMutation", m) +} + +// The UserFunc type is an adapter to allow the use of ordinary +// function as User mutator. +type UserFunc func(context.Context, *ent.UserMutation) (ent.Value, error) + +// Mutate calls f(ctx, m). +func (f UserFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { + if mv, ok := m.(*ent.UserMutation); ok { + return f(ctx, mv) + } + return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.UserMutation", m) } // Condition is a hook condition function. @@ -116,7 +139,6 @@ func HasFields(field string, fields ...string) Condition { // If executes the given hook under condition. // // hook.If(ComputeAverage, And(HasFields(...), HasAddedFields(...))) -// func If(hk ent.Hook, cond Condition) ent.Hook { return func(next ent.Mutator) ent.Mutator { return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) { @@ -131,7 +153,6 @@ func If(hk ent.Hook, cond Condition) ent.Hook { // On executes the given hook only for the given operation. // // hook.On(Log, ent.Delete|ent.Create) -// func On(hk ent.Hook, op ent.Op) ent.Hook { return If(hk, HasOp(op)) } @@ -139,7 +160,6 @@ func On(hk ent.Hook, op ent.Op) ent.Hook { // Unless skips the given hook only for the given operation. // // hook.Unless(Log, ent.Update|ent.UpdateOne) -// func Unless(hk ent.Hook, op ent.Op) ent.Hook { return If(hk, Not(HasOp(op))) } @@ -160,7 +180,6 @@ func FixedError(err error) ent.Hook { // Reject(ent.Delete|ent.Update), // } // } -// func Reject(op ent.Op) ent.Hook { hk := FixedError(fmt.Errorf("%s operation is not allowed", op)) return On(hk, op) diff --git a/ent/http/create.go b/ent/http/create.go deleted file mode 100644 index 178975d..0000000 --- a/ent/http/create.go +++ /dev/null @@ -1,224 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package http - -import ( - "net/http" - "strings" - "t/ent" - "t/ent/compartment" - "t/ent/entry" - "t/ent/fridge" - "t/ent/item" - - "github.com/mailru/easyjson" - "go.uber.org/zap" -) - -// Create creates a new ent.Compartment and stores it in the database. -func (h CompartmentHandler) Create(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Create")) - // Get the post data. - var d CompartmentCreateRequest - if err := easyjson.UnmarshalFromReader(r.Body, &d); err != nil { - l.Error("error decoding json", zap.Error(err)) - BadRequest(w, "invalid json string") - return - } - // Save the data. - b := h.client.Compartment.Create() - e, err := b.Save(r.Context()) - if err != nil { - switch { - default: - l.Error("could not create compartment", zap.Error(err)) - InternalServerError(w, nil) - } - return - } - // Store id of fresh entity to log errors for the reload. - id := e.ID - // Reload entry. - q := h.client.Compartment.Query().Where(compartment.ID(e.ID)) - ret, err := q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could not read compartment", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("compartment rendered", zap.Int("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewCompartment3324871446View(ret), w) -} - -// Create creates a new ent.Entry and stores it in the database. -func (h EntryHandler) Create(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Create")) - // Get the post data. - var d EntryCreateRequest - if err := easyjson.UnmarshalFromReader(r.Body, &d); err != nil { - l.Error("error decoding json", zap.Error(err)) - BadRequest(w, "invalid json string") - return - } - // Validate the data. - errs := make(map[string]string) - if d.User == nil { - errs["user"] = `missing required field: "user"` - } else if err := entry.UserValidator(*d.User); err != nil { - errs["user"] = strings.TrimPrefix(err.Error(), "entry: ") - } - if d.First == nil { - errs["first"] = `missing required field: "first"` - } - if len(errs) > 0 { - l.Info("validation failed", zapFields(errs)...) - BadRequest(w, errs) - return - } - // Save the data. - b := h.client.Entry.Create() - if d.User != nil { - b.SetUser(*d.User) - } - if d.First != nil { - b.SetFirst(*d.First) - } - if d.CreatedAt != nil { - b.SetCreatedAt(*d.CreatedAt) - } - e, err := b.Save(r.Context()) - if err != nil { - switch { - default: - l.Error("could not create entry", zap.Error(err)) - InternalServerError(w, nil) - } - return - } - // Store id of fresh entity to log errors for the reload. - id := e.ID - // Reload entry. - q := h.client.Entry.Query().Where(entry.ID(e.ID)) - ret, err := q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.String("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.String("id", id)) - BadRequest(w, msg) - default: - l.Error("could not read entry", zap.Error(err), zap.String("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("entry rendered", zap.String("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewEntry2675665849View(ret), w) -} - -// Create creates a new ent.Fridge and stores it in the database. -func (h FridgeHandler) Create(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Create")) - // Get the post data. - var d FridgeCreateRequest - if err := easyjson.UnmarshalFromReader(r.Body, &d); err != nil { - l.Error("error decoding json", zap.Error(err)) - BadRequest(w, "invalid json string") - return - } - // Save the data. - b := h.client.Fridge.Create() - e, err := b.Save(r.Context()) - if err != nil { - switch { - default: - l.Error("could not create fridge", zap.Error(err)) - InternalServerError(w, nil) - } - return - } - // Store id of fresh entity to log errors for the reload. - id := e.ID - // Reload entry. - q := h.client.Fridge.Query().Where(fridge.ID(e.ID)) - ret, err := q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could not read fridge", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("fridge rendered", zap.Int("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewFridge2211356377View(ret), w) -} - -// Create creates a new ent.Item and stores it in the database. -func (h ItemHandler) Create(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Create")) - // Get the post data. - var d ItemCreateRequest - if err := easyjson.UnmarshalFromReader(r.Body, &d); err != nil { - l.Error("error decoding json", zap.Error(err)) - BadRequest(w, "invalid json string") - return - } - // Save the data. - b := h.client.Item.Create() - e, err := b.Save(r.Context()) - if err != nil { - switch { - default: - l.Error("could not create item", zap.Error(err)) - InternalServerError(w, nil) - } - return - } - // Store id of fresh entity to log errors for the reload. - id := e.ID - // Reload entry. - q := h.client.Item.Query().Where(item.ID(e.ID)) - ret, err := q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could not read item", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("item rendered", zap.Int("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewItem1548468123View(ret), w) -} diff --git a/ent/http/delete.go b/ent/http/delete.go deleted file mode 100644 index c182aee..0000000 --- a/ent/http/delete.go +++ /dev/null @@ -1,116 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package http - -import ( - "net/http" - "strconv" - "t/ent" - - "github.com/go-chi/chi/v5" - "go.uber.org/zap" -) - -// Delete removes a ent.Compartment from the database. -func (h CompartmentHandler) Delete(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Delete")) - // ID is URL parameter. - id, err := strconv.Atoi(chi.URLParam(r, "id")) - if err != nil { - l.Error("error getting id from url parameter", zap.String("id", chi.URLParam(r, "id")), zap.Error(err)) - BadRequest(w, "id must be an integer") - return - } - err = h.client.Compartment.DeleteOneID(id).Exec(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - default: - l.Error("could-not-delete-compartment", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("compartment deleted", zap.Int("id", id)) - w.WriteHeader(http.StatusNoContent) -} - -// Delete removes a ent.Entry from the database. -func (h EntryHandler) Delete(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Delete")) - // ID is URL parameter. - var err error - id := chi.URLParam(r, "id") - err = h.client.Entry.DeleteOneID(id).Exec(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.String("id", id)) - NotFound(w, msg) - default: - l.Error("could-not-delete-entry", zap.Error(err), zap.String("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("entry deleted", zap.String("id", id)) - w.WriteHeader(http.StatusNoContent) -} - -// Delete removes a ent.Fridge from the database. -func (h FridgeHandler) Delete(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Delete")) - // ID is URL parameter. - id, err := strconv.Atoi(chi.URLParam(r, "id")) - if err != nil { - l.Error("error getting id from url parameter", zap.String("id", chi.URLParam(r, "id")), zap.Error(err)) - BadRequest(w, "id must be an integer") - return - } - err = h.client.Fridge.DeleteOneID(id).Exec(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - default: - l.Error("could-not-delete-fridge", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("fridge deleted", zap.Int("id", id)) - w.WriteHeader(http.StatusNoContent) -} - -// Delete removes a ent.Item from the database. -func (h ItemHandler) Delete(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Delete")) - // ID is URL parameter. - id, err := strconv.Atoi(chi.URLParam(r, "id")) - if err != nil { - l.Error("error getting id from url parameter", zap.String("id", chi.URLParam(r, "id")), zap.Error(err)) - BadRequest(w, "id must be an integer") - return - } - err = h.client.Item.DeleteOneID(id).Exec(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - default: - l.Error("could-not-delete-item", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("item deleted", zap.Int("id", id)) - w.WriteHeader(http.StatusNoContent) -} diff --git a/ent/http/easyjson.go b/ent/http/easyjson.go deleted file mode 100644 index 31e313b..0000000 --- a/ent/http/easyjson.go +++ /dev/null @@ -1,1075 +0,0 @@ -// Code generated by easyjson for marshaling/unmarshaling. DO NOT EDIT. - -package http - -import ( - json "encoding/json" - easyjson "github.com/mailru/easyjson" - jlexer "github.com/mailru/easyjson/jlexer" - jwriter "github.com/mailru/easyjson/jwriter" - time "time" -) - -// suppress unused package warning -var ( - _ *json.RawMessage - _ *jlexer.Lexer - _ *jwriter.Writer - _ easyjson.Marshaler -) - -func easyjsonC5a4559bDecodeTEntHttp(in *jlexer.Lexer, out *ItemUpdateRequest) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp(out *jwriter.Writer, in ItemUpdateRequest) { - out.RawByte('{') - first := true - _ = first - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v ItemUpdateRequest) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *ItemUpdateRequest) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp1(in *jlexer.Lexer, out *ItemCreateRequest) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp1(out *jwriter.Writer, in ItemCreateRequest) { - out.RawByte('{') - first := true - _ = first - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v ItemCreateRequest) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp1(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *ItemCreateRequest) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp1(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp2(in *jlexer.Lexer, out *Item1548468123Views) { - isTopLevel := in.IsStart() - if in.IsNull() { - in.Skip() - *out = nil - } else { - in.Delim('[') - if *out == nil { - if !in.IsDelim(']') { - *out = make(Item1548468123Views, 0, 8) - } else { - *out = Item1548468123Views{} - } - } else { - *out = (*out)[:0] - } - for !in.IsDelim(']') { - var v1 *Item1548468123View - if in.IsNull() { - in.Skip() - v1 = nil - } else { - if v1 == nil { - v1 = new(Item1548468123View) - } - (*v1).UnmarshalEasyJSON(in) - } - *out = append(*out, v1) - in.WantComma() - } - in.Delim(']') - } - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp2(out *jwriter.Writer, in Item1548468123Views) { - if in == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 { - out.RawString("null") - } else { - out.RawByte('[') - for v2, v3 := range in { - if v2 > 0 { - out.RawByte(',') - } - if v3 == nil { - out.RawString("null") - } else { - (*v3).MarshalEasyJSON(out) - } - } - out.RawByte(']') - } -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v Item1548468123Views) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp2(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *Item1548468123Views) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp2(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp3(in *jlexer.Lexer, out *Item1548468123View) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - case "id": - out.ID = int(in.Int()) - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp3(out *jwriter.Writer, in Item1548468123View) { - out.RawByte('{') - first := true - _ = first - if in.ID != 0 { - const prefix string = ",\"id\":" - first = false - out.RawString(prefix[1:]) - out.Int(int(in.ID)) - } - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v Item1548468123View) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp3(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *Item1548468123View) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp3(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp4(in *jlexer.Lexer, out *FridgeUpdateRequest) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp4(out *jwriter.Writer, in FridgeUpdateRequest) { - out.RawByte('{') - first := true - _ = first - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v FridgeUpdateRequest) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp4(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *FridgeUpdateRequest) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp4(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp5(in *jlexer.Lexer, out *FridgeCreateRequest) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp5(out *jwriter.Writer, in FridgeCreateRequest) { - out.RawByte('{') - first := true - _ = first - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v FridgeCreateRequest) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp5(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *FridgeCreateRequest) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp5(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp6(in *jlexer.Lexer, out *Fridge2211356377Views) { - isTopLevel := in.IsStart() - if in.IsNull() { - in.Skip() - *out = nil - } else { - in.Delim('[') - if *out == nil { - if !in.IsDelim(']') { - *out = make(Fridge2211356377Views, 0, 8) - } else { - *out = Fridge2211356377Views{} - } - } else { - *out = (*out)[:0] - } - for !in.IsDelim(']') { - var v4 *Fridge2211356377View - if in.IsNull() { - in.Skip() - v4 = nil - } else { - if v4 == nil { - v4 = new(Fridge2211356377View) - } - (*v4).UnmarshalEasyJSON(in) - } - *out = append(*out, v4) - in.WantComma() - } - in.Delim(']') - } - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp6(out *jwriter.Writer, in Fridge2211356377Views) { - if in == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 { - out.RawString("null") - } else { - out.RawByte('[') - for v5, v6 := range in { - if v5 > 0 { - out.RawByte(',') - } - if v6 == nil { - out.RawString("null") - } else { - (*v6).MarshalEasyJSON(out) - } - } - out.RawByte(']') - } -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v Fridge2211356377Views) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp6(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *Fridge2211356377Views) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp6(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp7(in *jlexer.Lexer, out *Fridge2211356377View) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - case "id": - out.ID = int(in.Int()) - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp7(out *jwriter.Writer, in Fridge2211356377View) { - out.RawByte('{') - first := true - _ = first - if in.ID != 0 { - const prefix string = ",\"id\":" - first = false - out.RawString(prefix[1:]) - out.Int(int(in.ID)) - } - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v Fridge2211356377View) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp7(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *Fridge2211356377View) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp7(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp8(in *jlexer.Lexer, out *ErrResponse) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - case "code": - out.Code = int(in.Int()) - case "status": - out.Status = string(in.String()) - case "errors": - if m, ok := out.Errors.(easyjson.Unmarshaler); ok { - m.UnmarshalEasyJSON(in) - } else if m, ok := out.Errors.(json.Unmarshaler); ok { - _ = m.UnmarshalJSON(in.Raw()) - } else { - out.Errors = in.Interface() - } - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp8(out *jwriter.Writer, in ErrResponse) { - out.RawByte('{') - first := true - _ = first - { - const prefix string = ",\"code\":" - out.RawString(prefix[1:]) - out.Int(int(in.Code)) - } - { - const prefix string = ",\"status\":" - out.RawString(prefix) - out.String(string(in.Status)) - } - if in.Errors != nil { - const prefix string = ",\"errors\":" - out.RawString(prefix) - if m, ok := in.Errors.(easyjson.Marshaler); ok { - m.MarshalEasyJSON(out) - } else if m, ok := in.Errors.(json.Marshaler); ok { - out.Raw(m.MarshalJSON()) - } else { - out.Raw(json.Marshal(in.Errors)) - } - } - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v ErrResponse) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp8(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *ErrResponse) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp8(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp9(in *jlexer.Lexer, out *EntryUpdateRequest) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp9(out *jwriter.Writer, in EntryUpdateRequest) { - out.RawByte('{') - first := true - _ = first - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v EntryUpdateRequest) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp9(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *EntryUpdateRequest) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp9(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp10(in *jlexer.Lexer, out *EntryCreateRequest) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - case "user": - if in.IsNull() { - in.Skip() - out.User = nil - } else { - if out.User == nil { - out.User = new(string) - } - *out.User = string(in.String()) - } - case "first": - if in.IsNull() { - in.Skip() - out.First = nil - } else { - if out.First == nil { - out.First = new(int) - } - *out.First = int(in.Int()) - } - case "created_at": - if in.IsNull() { - in.Skip() - out.CreatedAt = nil - } else { - if out.CreatedAt == nil { - out.CreatedAt = new(time.Time) - } - if data := in.Raw(); in.Ok() { - in.AddError((*out.CreatedAt).UnmarshalJSON(data)) - } - } - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp10(out *jwriter.Writer, in EntryCreateRequest) { - out.RawByte('{') - first := true - _ = first - { - const prefix string = ",\"user\":" - out.RawString(prefix[1:]) - if in.User == nil { - out.RawString("null") - } else { - out.String(string(*in.User)) - } - } - { - const prefix string = ",\"first\":" - out.RawString(prefix) - if in.First == nil { - out.RawString("null") - } else { - out.Int(int(*in.First)) - } - } - { - const prefix string = ",\"created_at\":" - out.RawString(prefix) - if in.CreatedAt == nil { - out.RawString("null") - } else { - out.Raw((*in.CreatedAt).MarshalJSON()) - } - } - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v EntryCreateRequest) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp10(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *EntryCreateRequest) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp10(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp11(in *jlexer.Lexer, out *Entry2675665849Views) { - isTopLevel := in.IsStart() - if in.IsNull() { - in.Skip() - *out = nil - } else { - in.Delim('[') - if *out == nil { - if !in.IsDelim(']') { - *out = make(Entry2675665849Views, 0, 8) - } else { - *out = Entry2675665849Views{} - } - } else { - *out = (*out)[:0] - } - for !in.IsDelim(']') { - var v7 *Entry2675665849View - if in.IsNull() { - in.Skip() - v7 = nil - } else { - if v7 == nil { - v7 = new(Entry2675665849View) - } - (*v7).UnmarshalEasyJSON(in) - } - *out = append(*out, v7) - in.WantComma() - } - in.Delim(']') - } - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp11(out *jwriter.Writer, in Entry2675665849Views) { - if in == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 { - out.RawString("null") - } else { - out.RawByte('[') - for v8, v9 := range in { - if v8 > 0 { - out.RawByte(',') - } - if v9 == nil { - out.RawString("null") - } else { - (*v9).MarshalEasyJSON(out) - } - } - out.RawByte(']') - } -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v Entry2675665849Views) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp11(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *Entry2675665849Views) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp11(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp12(in *jlexer.Lexer, out *Entry2675665849View) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - case "id": - out.ID = string(in.String()) - case "user": - out.User = string(in.String()) - case "first": - out.First = int(in.Int()) - case "created_at": - if data := in.Raw(); in.Ok() { - in.AddError((out.CreatedAt).UnmarshalJSON(data)) - } - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp12(out *jwriter.Writer, in Entry2675665849View) { - out.RawByte('{') - first := true - _ = first - if in.ID != "" { - const prefix string = ",\"id\":" - first = false - out.RawString(prefix[1:]) - out.String(string(in.ID)) - } - if in.User != "" { - const prefix string = ",\"user\":" - if first { - first = false - out.RawString(prefix[1:]) - } else { - out.RawString(prefix) - } - out.String(string(in.User)) - } - if in.First != 0 { - const prefix string = ",\"first\":" - if first { - first = false - out.RawString(prefix[1:]) - } else { - out.RawString(prefix) - } - out.Int(int(in.First)) - } - if true { - const prefix string = ",\"created_at\":" - if first { - first = false - out.RawString(prefix[1:]) - } else { - out.RawString(prefix) - } - out.Raw((in.CreatedAt).MarshalJSON()) - } - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v Entry2675665849View) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp12(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *Entry2675665849View) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp12(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp13(in *jlexer.Lexer, out *CompartmentUpdateRequest) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp13(out *jwriter.Writer, in CompartmentUpdateRequest) { - out.RawByte('{') - first := true - _ = first - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v CompartmentUpdateRequest) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp13(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *CompartmentUpdateRequest) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp13(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp14(in *jlexer.Lexer, out *CompartmentCreateRequest) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp14(out *jwriter.Writer, in CompartmentCreateRequest) { - out.RawByte('{') - first := true - _ = first - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v CompartmentCreateRequest) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp14(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *CompartmentCreateRequest) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp14(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp15(in *jlexer.Lexer, out *Compartment3324871446Views) { - isTopLevel := in.IsStart() - if in.IsNull() { - in.Skip() - *out = nil - } else { - in.Delim('[') - if *out == nil { - if !in.IsDelim(']') { - *out = make(Compartment3324871446Views, 0, 8) - } else { - *out = Compartment3324871446Views{} - } - } else { - *out = (*out)[:0] - } - for !in.IsDelim(']') { - var v10 *Compartment3324871446View - if in.IsNull() { - in.Skip() - v10 = nil - } else { - if v10 == nil { - v10 = new(Compartment3324871446View) - } - (*v10).UnmarshalEasyJSON(in) - } - *out = append(*out, v10) - in.WantComma() - } - in.Delim(']') - } - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp15(out *jwriter.Writer, in Compartment3324871446Views) { - if in == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 { - out.RawString("null") - } else { - out.RawByte('[') - for v11, v12 := range in { - if v11 > 0 { - out.RawByte(',') - } - if v12 == nil { - out.RawString("null") - } else { - (*v12).MarshalEasyJSON(out) - } - } - out.RawByte(']') - } -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v Compartment3324871446Views) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp15(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *Compartment3324871446Views) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp15(l, v) -} -func easyjsonC5a4559bDecodeTEntHttp16(in *jlexer.Lexer, out *Compartment3324871446View) { - isTopLevel := in.IsStart() - if in.IsNull() { - if isTopLevel { - in.Consumed() - } - in.Skip() - return - } - in.Delim('{') - for !in.IsDelim('}') { - key := in.UnsafeFieldName(false) - in.WantColon() - if in.IsNull() { - in.Skip() - in.WantComma() - continue - } - switch key { - case "id": - out.ID = int(in.Int()) - default: - in.AddError(&jlexer.LexerError{ - Offset: in.GetPos(), - Reason: "unknown field", - Data: key, - }) - } - in.WantComma() - } - in.Delim('}') - if isTopLevel { - in.Consumed() - } -} -func easyjsonC5a4559bEncodeTEntHttp16(out *jwriter.Writer, in Compartment3324871446View) { - out.RawByte('{') - first := true - _ = first - if in.ID != 0 { - const prefix string = ",\"id\":" - first = false - out.RawString(prefix[1:]) - out.Int(int(in.ID)) - } - out.RawByte('}') -} - -// MarshalEasyJSON supports easyjson.Marshaler interface -func (v Compartment3324871446View) MarshalEasyJSON(w *jwriter.Writer) { - easyjsonC5a4559bEncodeTEntHttp16(w, v) -} - -// UnmarshalEasyJSON supports easyjson.Unmarshaler interface -func (v *Compartment3324871446View) UnmarshalEasyJSON(l *jlexer.Lexer) { - easyjsonC5a4559bDecodeTEntHttp16(l, v) -} diff --git a/ent/http/handler.go b/ent/http/handler.go deleted file mode 100644 index 6cc8b74..0000000 --- a/ent/http/handler.go +++ /dev/null @@ -1,185 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package http - -import ( - "strings" - "t/ent" - - "github.com/go-chi/chi/v5" - "go.uber.org/zap" -) - -// NewHandler returns a ready to use handler with all generated endpoints mounted. -func NewHandler(c *ent.Client, l *zap.Logger) chi.Router { - r := chi.NewRouter() - MountRoutes(c, l, r) - return r -} - -// MountRoutes mounts all generated routes on the given router. -func MountRoutes(c *ent.Client, l *zap.Logger, r chi.Router) { - NewCompartmentHandler(c, l).MountRoutes(r) - NewEntryHandler(c, l).MountRoutes(r) - NewFridgeHandler(c, l).MountRoutes(r) - NewItemHandler(c, l).MountRoutes(r) -} - -// CompartmentHandler handles http crud operations on ent.Compartment. -type CompartmentHandler struct { - client *ent.Client - log *zap.Logger -} - -func NewCompartmentHandler(c *ent.Client, l *zap.Logger) *CompartmentHandler { - return &CompartmentHandler{ - client: c, - log: l.With(zap.String("handler", "CompartmentHandler")), - } -} -func (h *CompartmentHandler) MountCreateRoute(r chi.Router) *CompartmentHandler { - r.Post("/compartments", h.Create) - return h -} -func (h *CompartmentHandler) MountReadRoute(r chi.Router) *CompartmentHandler { - r.Get("/compartments/{id}", h.Read) - return h -} -func (h *CompartmentHandler) MountUpdateRoute(r chi.Router) *CompartmentHandler { - r.Patch("/compartments/{id}", h.Update) - return h -} -func (h *CompartmentHandler) MountDeleteRoute(r chi.Router) *CompartmentHandler { - r.Delete("/compartments/{id}", h.Delete) - return h -} -func (h *CompartmentHandler) MountListRoute(r chi.Router) *CompartmentHandler { - r.Get("/compartments", h.List) - return h -} -func (h *CompartmentHandler) MountRoutes(r chi.Router) { - h.MountCreateRoute(r).MountReadRoute(r).MountUpdateRoute(r).MountDeleteRoute(r).MountListRoute(r) -} - -// EntryHandler handles http crud operations on ent.Entry. -type EntryHandler struct { - client *ent.Client - log *zap.Logger -} - -func NewEntryHandler(c *ent.Client, l *zap.Logger) *EntryHandler { - return &EntryHandler{ - client: c, - log: l.With(zap.String("handler", "EntryHandler")), - } -} -func (h *EntryHandler) MountCreateRoute(r chi.Router) *EntryHandler { - r.Post("/entries", h.Create) - return h -} -func (h *EntryHandler) MountReadRoute(r chi.Router) *EntryHandler { - r.Get("/entries/{id}", h.Read) - return h -} -func (h *EntryHandler) MountUpdateRoute(r chi.Router) *EntryHandler { - r.Patch("/entries/{id}", h.Update) - return h -} -func (h *EntryHandler) MountDeleteRoute(r chi.Router) *EntryHandler { - r.Delete("/entries/{id}", h.Delete) - return h -} -func (h *EntryHandler) MountListRoute(r chi.Router) *EntryHandler { - r.Get("/entries", h.List) - return h -} -func (h *EntryHandler) MountRoutes(r chi.Router) { - h.MountCreateRoute(r).MountReadRoute(r).MountUpdateRoute(r).MountDeleteRoute(r).MountListRoute(r) -} - -// FridgeHandler handles http crud operations on ent.Fridge. -type FridgeHandler struct { - client *ent.Client - log *zap.Logger -} - -func NewFridgeHandler(c *ent.Client, l *zap.Logger) *FridgeHandler { - return &FridgeHandler{ - client: c, - log: l.With(zap.String("handler", "FridgeHandler")), - } -} -func (h *FridgeHandler) MountCreateRoute(r chi.Router) *FridgeHandler { - r.Post("/fridges", h.Create) - return h -} -func (h *FridgeHandler) MountReadRoute(r chi.Router) *FridgeHandler { - r.Get("/fridges/{id}", h.Read) - return h -} -func (h *FridgeHandler) MountUpdateRoute(r chi.Router) *FridgeHandler { - r.Patch("/fridges/{id}", h.Update) - return h -} -func (h *FridgeHandler) MountDeleteRoute(r chi.Router) *FridgeHandler { - r.Delete("/fridges/{id}", h.Delete) - return h -} -func (h *FridgeHandler) MountListRoute(r chi.Router) *FridgeHandler { - r.Get("/fridges", h.List) - return h -} -func (h *FridgeHandler) MountRoutes(r chi.Router) { - h.MountCreateRoute(r).MountReadRoute(r).MountUpdateRoute(r).MountDeleteRoute(r).MountListRoute(r) -} - -// ItemHandler handles http crud operations on ent.Item. -type ItemHandler struct { - client *ent.Client - log *zap.Logger -} - -func NewItemHandler(c *ent.Client, l *zap.Logger) *ItemHandler { - return &ItemHandler{ - client: c, - log: l.With(zap.String("handler", "ItemHandler")), - } -} -func (h *ItemHandler) MountCreateRoute(r chi.Router) *ItemHandler { - r.Post("/items", h.Create) - return h -} -func (h *ItemHandler) MountReadRoute(r chi.Router) *ItemHandler { - r.Get("/items/{id}", h.Read) - return h -} -func (h *ItemHandler) MountUpdateRoute(r chi.Router) *ItemHandler { - r.Patch("/items/{id}", h.Update) - return h -} -func (h *ItemHandler) MountDeleteRoute(r chi.Router) *ItemHandler { - r.Delete("/items/{id}", h.Delete) - return h -} -func (h *ItemHandler) MountListRoute(r chi.Router) *ItemHandler { - r.Get("/items", h.List) - return h -} -func (h *ItemHandler) MountRoutes(r chi.Router) { - h.MountCreateRoute(r).MountReadRoute(r).MountUpdateRoute(r).MountDeleteRoute(r).MountListRoute(r) -} - -func stripEntError(err error) string { - return strings.TrimPrefix(err.Error(), "ent: ") -} - -func zapFields(errs map[string]string) []zap.Field { - if errs == nil || len(errs) == 0 { - return nil - } - r := make([]zap.Field, 0) - for k, v := range errs { - r = append(r, zap.String(k, v)) - } - return r -} diff --git a/ent/http/list.go b/ent/http/list.go deleted file mode 100644 index e79fa63..0000000 --- a/ent/http/list.go +++ /dev/null @@ -1,147 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package http - -import ( - "net/http" - "strconv" - - "github.com/mailru/easyjson" - "go.uber.org/zap" -) - -// Read fetches the ent.Compartment identified by a given url-parameter from the -// database and returns it to the client. -func (h *CompartmentHandler) List(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "List")) - q := h.client.Compartment.Query() - var err error - page := 1 - if d := r.URL.Query().Get("page"); d != "" { - page, err = strconv.Atoi(d) - if err != nil { - l.Info("error parsing query parameter 'page'", zap.String("page", d), zap.Error(err)) - BadRequest(w, "page must be an integer greater zero") - return - } - } - itemsPerPage := 30 - if d := r.URL.Query().Get("itemsPerPage"); d != "" { - itemsPerPage, err = strconv.Atoi(d) - if err != nil { - l.Info("error parsing query parameter 'itemsPerPage'", zap.String("itemsPerPage", d), zap.Error(err)) - BadRequest(w, "itemsPerPage must be an integer greater zero") - return - } - } - es, err := q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage).All(r.Context()) - if err != nil { - l.Error("error fetching compartments from db", zap.Error(err)) - InternalServerError(w, nil) - return - } - l.Info("compartments rendered", zap.Int("amount", len(es))) - easyjson.MarshalToHTTPResponseWriter(NewCompartment3324871446Views(es), w) -} - -// Read fetches the ent.Entry identified by a given url-parameter from the -// database and returns it to the client. -func (h *EntryHandler) List(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "List")) - q := h.client.Entry.Query() - var err error - page := 1 - if d := r.URL.Query().Get("page"); d != "" { - page, err = strconv.Atoi(d) - if err != nil { - l.Info("error parsing query parameter 'page'", zap.String("page", d), zap.Error(err)) - BadRequest(w, "page must be an integer greater zero") - return - } - } - itemsPerPage := 30 - if d := r.URL.Query().Get("itemsPerPage"); d != "" { - itemsPerPage, err = strconv.Atoi(d) - if err != nil { - l.Info("error parsing query parameter 'itemsPerPage'", zap.String("itemsPerPage", d), zap.Error(err)) - BadRequest(w, "itemsPerPage must be an integer greater zero") - return - } - } - es, err := q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage).All(r.Context()) - if err != nil { - l.Error("error fetching entries from db", zap.Error(err)) - InternalServerError(w, nil) - return - } - l.Info("entries rendered", zap.Int("amount", len(es))) - easyjson.MarshalToHTTPResponseWriter(NewEntry2675665849Views(es), w) -} - -// Read fetches the ent.Fridge identified by a given url-parameter from the -// database and returns it to the client. -func (h *FridgeHandler) List(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "List")) - q := h.client.Fridge.Query() - var err error - page := 1 - if d := r.URL.Query().Get("page"); d != "" { - page, err = strconv.Atoi(d) - if err != nil { - l.Info("error parsing query parameter 'page'", zap.String("page", d), zap.Error(err)) - BadRequest(w, "page must be an integer greater zero") - return - } - } - itemsPerPage := 30 - if d := r.URL.Query().Get("itemsPerPage"); d != "" { - itemsPerPage, err = strconv.Atoi(d) - if err != nil { - l.Info("error parsing query parameter 'itemsPerPage'", zap.String("itemsPerPage", d), zap.Error(err)) - BadRequest(w, "itemsPerPage must be an integer greater zero") - return - } - } - es, err := q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage).All(r.Context()) - if err != nil { - l.Error("error fetching fridges from db", zap.Error(err)) - InternalServerError(w, nil) - return - } - l.Info("fridges rendered", zap.Int("amount", len(es))) - easyjson.MarshalToHTTPResponseWriter(NewFridge2211356377Views(es), w) -} - -// Read fetches the ent.Item identified by a given url-parameter from the -// database and returns it to the client. -func (h *ItemHandler) List(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "List")) - q := h.client.Item.Query() - var err error - page := 1 - if d := r.URL.Query().Get("page"); d != "" { - page, err = strconv.Atoi(d) - if err != nil { - l.Info("error parsing query parameter 'page'", zap.String("page", d), zap.Error(err)) - BadRequest(w, "page must be an integer greater zero") - return - } - } - itemsPerPage := 30 - if d := r.URL.Query().Get("itemsPerPage"); d != "" { - itemsPerPage, err = strconv.Atoi(d) - if err != nil { - l.Info("error parsing query parameter 'itemsPerPage'", zap.String("itemsPerPage", d), zap.Error(err)) - BadRequest(w, "itemsPerPage must be an integer greater zero") - return - } - } - es, err := q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage).All(r.Context()) - if err != nil { - l.Error("error fetching items from db", zap.Error(err)) - InternalServerError(w, nil) - return - } - l.Info("items rendered", zap.Int("amount", len(es))) - easyjson.MarshalToHTTPResponseWriter(NewItem1548468123Views(es), w) -} diff --git a/ent/http/read.go b/ent/http/read.go deleted file mode 100644 index 457f1e7..0000000 --- a/ent/http/read.go +++ /dev/null @@ -1,149 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package http - -import ( - "net/http" - "strconv" - "t/ent" - "t/ent/compartment" - "t/ent/entry" - "t/ent/fridge" - "t/ent/item" - - "github.com/go-chi/chi/v5" - "github.com/mailru/easyjson" - "go.uber.org/zap" -) - -// Read fetches the ent.Compartment identified by a given url-parameter from the -// database and renders it to the client. -func (h *CompartmentHandler) Read(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Read")) - // ID is URL parameter. - id, err := strconv.Atoi(chi.URLParam(r, "id")) - if err != nil { - l.Error("error getting id from url parameter", zap.String("id", chi.URLParam(r, "id")), zap.Error(err)) - BadRequest(w, "id must be an integer") - return - } - // Create the query to fetch the Compartment - q := h.client.Compartment.Query().Where(compartment.ID(id)) - e, err := q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could not read compartment", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("compartment rendered", zap.Int("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewCompartment3324871446View(e), w) -} - -// Read fetches the ent.Entry identified by a given url-parameter from the -// database and renders it to the client. -func (h *EntryHandler) Read(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Read")) - // ID is URL parameter. - var err error - id := chi.URLParam(r, "id") - // Create the query to fetch the Entry - q := h.client.Entry.Query().Where(entry.ID(id)) - e, err := q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.String("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.String("id", id)) - BadRequest(w, msg) - default: - l.Error("could not read entry", zap.Error(err), zap.String("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("entry rendered", zap.String("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewEntry2675665849View(e), w) -} - -// Read fetches the ent.Fridge identified by a given url-parameter from the -// database and renders it to the client. -func (h *FridgeHandler) Read(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Read")) - // ID is URL parameter. - id, err := strconv.Atoi(chi.URLParam(r, "id")) - if err != nil { - l.Error("error getting id from url parameter", zap.String("id", chi.URLParam(r, "id")), zap.Error(err)) - BadRequest(w, "id must be an integer") - return - } - // Create the query to fetch the Fridge - q := h.client.Fridge.Query().Where(fridge.ID(id)) - e, err := q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could not read fridge", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("fridge rendered", zap.Int("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewFridge2211356377View(e), w) -} - -// Read fetches the ent.Item identified by a given url-parameter from the -// database and renders it to the client. -func (h *ItemHandler) Read(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Read")) - // ID is URL parameter. - id, err := strconv.Atoi(chi.URLParam(r, "id")) - if err != nil { - l.Error("error getting id from url parameter", zap.String("id", chi.URLParam(r, "id")), zap.Error(err)) - BadRequest(w, "id must be an integer") - return - } - // Create the query to fetch the Item - q := h.client.Item.Query().Where(item.ID(id)) - e, err := q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could not read item", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("item rendered", zap.Int("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewItem1548468123View(e), w) -} diff --git a/ent/http/relations.go b/ent/http/relations.go deleted file mode 100644 index 2e1e102..0000000 --- a/ent/http/relations.go +++ /dev/null @@ -1,3 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package http diff --git a/ent/http/request.go b/ent/http/request.go deleted file mode 100644 index ed56bab..0000000 --- a/ent/http/request.go +++ /dev/null @@ -1,42 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package http - -import ( - "time" -) - -// Payload of a ent.Compartment create request. -type CompartmentCreateRequest struct { -} - -// Payload of a ent.Compartment update request. -type CompartmentUpdateRequest struct { -} - -// Payload of a ent.Entry create request. -type EntryCreateRequest struct { - User *string `json:"user"` - First *int `json:"first"` - CreatedAt *time.Time `json:"created_at"` -} - -// Payload of a ent.Entry update request. -type EntryUpdateRequest struct { -} - -// Payload of a ent.Fridge create request. -type FridgeCreateRequest struct { -} - -// Payload of a ent.Fridge update request. -type FridgeUpdateRequest struct { -} - -// Payload of a ent.Item create request. -type ItemCreateRequest struct { -} - -// Payload of a ent.Item update request. -type ItemUpdateRequest struct { -} diff --git a/ent/http/response.go b/ent/http/response.go deleted file mode 100644 index 3099d93..0000000 --- a/ent/http/response.go +++ /dev/null @@ -1,200 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package http - -import ( - "net/http" - "strconv" - "t/ent" - "time" - - "github.com/mailru/easyjson" -) - -// Basic HTTP Error Response -type ErrResponse struct { - Code int `json:"code"` // http response status code - Status string `json:"status"` // user-level status message - Errors interface{} `json:"errors,omitempty"` // application-level error -} - -func (e ErrResponse) MarshalToHTTPResponseWriter(w http.ResponseWriter) (int, error) { - d, err := easyjson.Marshal(e) - if err != nil { - return 0, err - } - w.Header().Set("Content-Type", "application/json; charset=utf-8") - w.Header().Set("Content-Length", strconv.Itoa(len(d))) - w.WriteHeader(e.Code) - return w.Write(d) -} - -func BadRequest(w http.ResponseWriter, msg interface{}) (int, error) { - return ErrResponse{ - Code: http.StatusBadRequest, - Status: http.StatusText(http.StatusBadRequest), - Errors: msg, - }.MarshalToHTTPResponseWriter(w) -} - -func Conflict(w http.ResponseWriter, msg interface{}) (int, error) { - return ErrResponse{ - Code: http.StatusConflict, - Status: http.StatusText(http.StatusConflict), - Errors: msg, - }.MarshalToHTTPResponseWriter(w) -} - -func Forbidden(w http.ResponseWriter, msg interface{}) (int, error) { - return ErrResponse{ - Code: http.StatusForbidden, - Status: http.StatusText(http.StatusForbidden), - Errors: msg, - }.MarshalToHTTPResponseWriter(w) -} - -func InternalServerError(w http.ResponseWriter, msg interface{}) (int, error) { - return ErrResponse{ - Code: http.StatusInternalServerError, - Status: http.StatusText(http.StatusInternalServerError), - Errors: msg, - }.MarshalToHTTPResponseWriter(w) -} - -func NotFound(w http.ResponseWriter, msg interface{}) (int, error) { - return ErrResponse{ - Code: http.StatusNotFound, - Status: http.StatusText(http.StatusNotFound), - Errors: msg, - }.MarshalToHTTPResponseWriter(w) -} - -func Unauthorized(w http.ResponseWriter, msg interface{}) (int, error) { - return ErrResponse{ - Code: http.StatusUnauthorized, - Status: http.StatusText(http.StatusUnauthorized), - Errors: msg, - }.MarshalToHTTPResponseWriter(w) -} - -type ( - // Compartment3324871446View represents the data serialized for the following serialization group combinations: - // [] - Compartment3324871446View struct { - ID int `json:"id,omitempty"` - } - Compartment3324871446Views []*Compartment3324871446View -) - -func NewCompartment3324871446View(e *ent.Compartment) *Compartment3324871446View { - if e == nil { - return nil - } - return &Compartment3324871446View{ - ID: e.ID, - } -} - -func NewCompartment3324871446Views(es []*ent.Compartment) Compartment3324871446Views { - if len(es) == 0 { - return nil - } - r := make(Compartment3324871446Views, len(es)) - for i, e := range es { - r[i] = NewCompartment3324871446View(e) - } - return r -} - -type ( - // Entry2675665849View represents the data serialized for the following serialization group combinations: - // [] - Entry2675665849View struct { - ID string `json:"id,omitempty"` - User string `json:"user,omitempty"` - First int `json:"first,omitempty"` - CreatedAt time.Time `json:"created_at,omitempty"` - } - Entry2675665849Views []*Entry2675665849View -) - -func NewEntry2675665849View(e *ent.Entry) *Entry2675665849View { - if e == nil { - return nil - } - return &Entry2675665849View{ - ID: e.ID, - User: e.User, - First: e.First, - CreatedAt: e.CreatedAt, - } -} - -func NewEntry2675665849Views(es []*ent.Entry) Entry2675665849Views { - if len(es) == 0 { - return nil - } - r := make(Entry2675665849Views, len(es)) - for i, e := range es { - r[i] = NewEntry2675665849View(e) - } - return r -} - -type ( - // Fridge2211356377View represents the data serialized for the following serialization group combinations: - // [] - Fridge2211356377View struct { - ID int `json:"id,omitempty"` - } - Fridge2211356377Views []*Fridge2211356377View -) - -func NewFridge2211356377View(e *ent.Fridge) *Fridge2211356377View { - if e == nil { - return nil - } - return &Fridge2211356377View{ - ID: e.ID, - } -} - -func NewFridge2211356377Views(es []*ent.Fridge) Fridge2211356377Views { - if len(es) == 0 { - return nil - } - r := make(Fridge2211356377Views, len(es)) - for i, e := range es { - r[i] = NewFridge2211356377View(e) - } - return r -} - -type ( - // Item1548468123View represents the data serialized for the following serialization group combinations: - // [] - Item1548468123View struct { - ID int `json:"id,omitempty"` - } - Item1548468123Views []*Item1548468123View -) - -func NewItem1548468123View(e *ent.Item) *Item1548468123View { - if e == nil { - return nil - } - return &Item1548468123View{ - ID: e.ID, - } -} - -func NewItem1548468123Views(es []*ent.Item) Item1548468123Views { - if len(es) == 0 { - return nil - } - r := make(Item1548468123Views, len(es)) - for i, e := range es { - r[i] = NewItem1548468123View(e) - } - return r -} diff --git a/ent/http/update.go b/ent/http/update.go deleted file mode 100644 index 8bd6197..0000000 --- a/ent/http/update.go +++ /dev/null @@ -1,260 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package http - -import ( - "net/http" - "strconv" - "t/ent" - "t/ent/compartment" - "t/ent/entry" - "t/ent/fridge" - "t/ent/item" - - "github.com/go-chi/chi/v5" - "github.com/mailru/easyjson" - "go.uber.org/zap" -) - -// Update updates a given ent.Compartment and saves the changes to the database. -func (h CompartmentHandler) Update(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Update")) - // ID is URL parameter. - id, err := strconv.Atoi(chi.URLParam(r, "id")) - if err != nil { - l.Error("error getting id from url parameter", zap.String("id", chi.URLParam(r, "id")), zap.Error(err)) - BadRequest(w, "id must be an integer") - return - } - // Get the post data. - var d CompartmentUpdateRequest - if err := easyjson.UnmarshalFromReader(r.Body, &d); err != nil { - l.Error("error decoding json", zap.Error(err)) - BadRequest(w, "invalid json string") - return - } - // Save the data. - b := h.client.Compartment.UpdateOneID(id) - // Store in database. - e, err := b.Save(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could-not-update-compartment", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - // Reload entry. - q := h.client.Compartment.Query().Where(compartment.ID(e.ID)) - e, err = q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could-not-read-compartment", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("compartment rendered", zap.Int("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewCompartment3324871446View(e), w) -} - -// Update updates a given ent.Entry and saves the changes to the database. -func (h EntryHandler) Update(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Update")) - // ID is URL parameter. - var err error - id := chi.URLParam(r, "id") - // Get the post data. - var d EntryUpdateRequest - if err := easyjson.UnmarshalFromReader(r.Body, &d); err != nil { - l.Error("error decoding json", zap.Error(err)) - BadRequest(w, "invalid json string") - return - } - // Validate the data. - errs := make(map[string]string) - if len(errs) > 0 { - l.Info("validation failed", zapFields(errs)...) - BadRequest(w, errs) - return - } - // Save the data. - b := h.client.Entry.UpdateOneID(id) - // Store in database. - e, err := b.Save(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.String("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.String("id", id)) - BadRequest(w, msg) - default: - l.Error("could-not-update-entry", zap.Error(err), zap.String("id", id)) - InternalServerError(w, nil) - } - return - } - // Reload entry. - q := h.client.Entry.Query().Where(entry.ID(e.ID)) - e, err = q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.String("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.String("id", id)) - BadRequest(w, msg) - default: - l.Error("could-not-read-entry", zap.Error(err), zap.String("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("entry rendered", zap.String("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewEntry2675665849View(e), w) -} - -// Update updates a given ent.Fridge and saves the changes to the database. -func (h FridgeHandler) Update(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Update")) - // ID is URL parameter. - id, err := strconv.Atoi(chi.URLParam(r, "id")) - if err != nil { - l.Error("error getting id from url parameter", zap.String("id", chi.URLParam(r, "id")), zap.Error(err)) - BadRequest(w, "id must be an integer") - return - } - // Get the post data. - var d FridgeUpdateRequest - if err := easyjson.UnmarshalFromReader(r.Body, &d); err != nil { - l.Error("error decoding json", zap.Error(err)) - BadRequest(w, "invalid json string") - return - } - // Save the data. - b := h.client.Fridge.UpdateOneID(id) - // Store in database. - e, err := b.Save(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could-not-update-fridge", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - // Reload entry. - q := h.client.Fridge.Query().Where(fridge.ID(e.ID)) - e, err = q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could-not-read-fridge", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("fridge rendered", zap.Int("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewFridge2211356377View(e), w) -} - -// Update updates a given ent.Item and saves the changes to the database. -func (h ItemHandler) Update(w http.ResponseWriter, r *http.Request) { - l := h.log.With(zap.String("method", "Update")) - // ID is URL parameter. - id, err := strconv.Atoi(chi.URLParam(r, "id")) - if err != nil { - l.Error("error getting id from url parameter", zap.String("id", chi.URLParam(r, "id")), zap.Error(err)) - BadRequest(w, "id must be an integer") - return - } - // Get the post data. - var d ItemUpdateRequest - if err := easyjson.UnmarshalFromReader(r.Body, &d); err != nil { - l.Error("error decoding json", zap.Error(err)) - BadRequest(w, "invalid json string") - return - } - // Save the data. - b := h.client.Item.UpdateOneID(id) - // Store in database. - e, err := b.Save(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could-not-update-item", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - // Reload entry. - q := h.client.Item.Query().Where(item.ID(e.ID)) - e, err = q.Only(r.Context()) - if err != nil { - switch { - case ent.IsNotFound(err): - msg := stripEntError(err) - l.Info(msg, zap.Error(err), zap.Int("id", id)) - NotFound(w, msg) - case ent.IsNotSingular(err): - msg := stripEntError(err) - l.Error(msg, zap.Error(err), zap.Int("id", id)) - BadRequest(w, msg) - default: - l.Error("could-not-read-item", zap.Error(err), zap.Int("id", id)) - InternalServerError(w, nil) - } - return - } - l.Info("item rendered", zap.Int("id", id)) - easyjson.MarshalToHTTPResponseWriter(NewItem1548468123View(e), w) -} diff --git a/ent/migrate/migrate.go b/ent/migrate/migrate.go index 9bdaf52..1956a6b 100644 --- a/ent/migrate/migrate.go +++ b/ent/migrate/migrate.go @@ -1,4 +1,4 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package migrate @@ -28,9 +28,6 @@ var ( // and therefore, it's recommended to enable this option to get more // flexibility in the schema changes. WithDropIndex = schema.WithDropIndex - // WithFixture sets the foreign-key renaming option to the migration when upgrading - // ent from v0.1.0 (issue-#285). Defaults to false. - WithFixture = schema.WithFixture // WithForeignKeys enables creating foreign-key in schema DDL. This defaults to true. WithForeignKeys = schema.WithForeignKeys ) @@ -45,27 +42,23 @@ func NewSchema(drv dialect.Driver) *Schema { return &Schema{drv: drv} } // Create creates all schema resources. func (s *Schema) Create(ctx context.Context, opts ...schema.MigrateOption) error { + return Create(ctx, s, Tables, opts...) +} + +// Create creates all table resources using the given schema driver. +func Create(ctx context.Context, s *Schema, tables []*schema.Table, opts ...schema.MigrateOption) error { migrate, err := schema.NewMigrate(s.drv, opts...) if err != nil { return fmt.Errorf("ent/migrate: %w", err) } - return migrate.Create(ctx, Tables...) + return migrate.Create(ctx, tables...) } // WriteTo writes the schema changes to w instead of running them against the database. // -// if err := client.Schema.WriteTo(context.Background(), os.Stdout); err != nil { +// if err := client.Schema.WriteTo(context.Background(), os.Stdout); err != nil { // log.Fatal(err) -// } -// +// } func (s *Schema) WriteTo(ctx context.Context, w io.Writer, opts ...schema.MigrateOption) error { - drv := &schema.WriteDriver{ - Writer: w, - Driver: s.drv, - } - migrate, err := schema.NewMigrate(drv, opts...) - if err != nil { - return fmt.Errorf("ent/migrate: %w", err) - } - return migrate.Create(ctx, Tables...) + return Create(ctx, &Schema{drv: &schema.WriteDriver{Writer: w, Driver: s.drv}}, Tables, opts...) } diff --git a/ent/migrate/schema.go b/ent/migrate/schema.go index 86e62d0..5370c12 100644 --- a/ent/migrate/schema.go +++ b/ent/migrate/schema.go @@ -1,4 +1,4 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package migrate @@ -8,39 +8,87 @@ import ( ) var ( + // CardsColumns holds the columns for the "cards" table. + CardsColumns = []*schema.Column{ + {Name: "id", Type: field.TypeInt, Increment: true}, + {Name: "card", Type: field.TypeInt, Nullable: true}, + {Name: "status", Type: field.TypeString, Nullable: true}, + {Name: "cp", Type: field.TypeInt, Nullable: true}, + {Name: "url", Type: field.TypeString, Nullable: true, Default: "https://card.syui.ai"}, + {Name: "created_at", Type: field.TypeTime, Nullable: true}, + {Name: "user_card", Type: field.TypeInt}, + } + // CardsTable holds the schema information for the "cards" table. + CardsTable = &schema.Table{ + Name: "cards", + Columns: CardsColumns, + PrimaryKey: []*schema.Column{CardsColumns[0]}, + ForeignKeys: []*schema.ForeignKey{ + { + Symbol: "cards_users_card", + Columns: []*schema.Column{CardsColumns[6]}, + RefColumns: []*schema.Column{UsersColumns[0]}, + OnDelete: schema.NoAction, + }, + }, + } + // GroupsColumns holds the columns for the "groups" table. + GroupsColumns = []*schema.Column{ + {Name: "id", Type: field.TypeInt, Increment: true}, + {Name: "name", Type: field.TypeString}, + } + // GroupsTable holds the schema information for the "groups" table. + GroupsTable = &schema.Table{ + Name: "groups", + Columns: GroupsColumns, + PrimaryKey: []*schema.Column{GroupsColumns[0]}, + Indexes: []*schema.Index{ + { + Name: "group_name", + Unique: true, + Columns: []*schema.Column{GroupsColumns[1]}, + }, + }, + } // UsersColumns holds the columns for the "users" table. UsersColumns = []*schema.Column{ {Name: "id", Type: field.TypeInt, Increment: true}, - {Name: "user", Type: field.TypeString, Unique: true, Size: 7}, - {Name: "chara", Type: field.TypeString, Nullable: true, Default: "ponta"}, - {Name: "skill", Type: field.TypeInt, Nullable: true, Default: 7}, - {Name: "hp", Type: field.TypeInt, Nullable: true, Default: 7}, - {Name: "attack", Type: field.TypeInt, Nullable: true, Default: 8}, - {Name: "defense", Type: field.TypeInt, Nullable: true, Default: 19}, - {Name: "critical", Type: field.TypeInt, Nullable: true, Default: 7}, - {Name: "battle", Type: field.TypeInt, Nullable: true, Default: 1}, - {Name: "win", Type: field.TypeInt, Nullable: true, Default: 0}, - {Name: "day", Type: field.TypeInt, Nullable: true, Default: 0}, - {Name: "percentage", Type: field.TypeFloat64, Nullable: true, Default: 0}, - {Name: "limit", Type: field.TypeBool, Nullable: true, Default: false}, - {Name: "status", Type: field.TypeString, Nullable: true, Default: "normal"}, - {Name: "comment", Type: field.TypeString, Nullable: true, Default: ""}, + {Name: "username", Type: field.TypeString, Unique: true, Size: 30}, {Name: "created_at", Type: field.TypeTime, Nullable: true}, - {Name: "next", Type: field.TypeString, Nullable: true, Default: "20220617"}, {Name: "updated_at", Type: field.TypeTime, Nullable: true}, - {Name: "url", Type: field.TypeString, Nullable: true, Default: "https://syui.cf/api"}, + {Name: "next", Type: field.TypeString, Nullable: true, Default: "20230404"}, + {Name: "group_users", Type: field.TypeInt, Nullable: true}, } // UsersTable holds the schema information for the "users" table. UsersTable = &schema.Table{ Name: "users", Columns: UsersColumns, PrimaryKey: []*schema.Column{UsersColumns[0]}, + ForeignKeys: []*schema.ForeignKey{ + { + Symbol: "users_groups_users", + Columns: []*schema.Column{UsersColumns[5]}, + RefColumns: []*schema.Column{GroupsColumns[0]}, + OnDelete: schema.SetNull, + }, + }, + Indexes: []*schema.Index{ + { + Name: "user_username", + Unique: true, + Columns: []*schema.Column{UsersColumns[1]}, + }, + }, } // Tables holds all the tables in the schema. Tables = []*schema.Table{ + CardsTable, + GroupsTable, UsersTable, } ) func init() { + CardsTable.ForeignKeys[0].RefTable = UsersTable + UsersTable.ForeignKeys[0].RefTable = GroupsTable } diff --git a/ent/mutation.go b/ent/mutation.go index 978c5b5..914f384 100644 --- a/ent/mutation.go +++ b/ent/mutation.go @@ -1,4 +1,4 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package ent @@ -7,11 +7,14 @@ import ( "errors" "fmt" "sync" + "t/ent/card" + "t/ent/group" "t/ent/predicate" - "t/ent/users" + "t/ent/user" "time" "entgo.io/ent" + "entgo.io/ent/dialect/sql" ) const ( @@ -23,59 +26,43 @@ const ( OpUpdateOne = ent.OpUpdateOne // Node types. - TypeUsers = "Users" + TypeCard = "Card" + TypeGroup = "Group" + TypeUser = "User" ) -// UsersMutation represents an operation that mutates the Users nodes in the graph. -type UsersMutation struct { +// CardMutation represents an operation that mutates the Card nodes in the graph. +type CardMutation struct { config op Op typ string id *int - user *string - chara *string - skill *int - addskill *int - hp *int - addhp *int - attack *int - addattack *int - defense *int - adddefense *int - critical *int - addcritical *int - battle *int - addbattle *int - win *int - addwin *int - day *int - addday *int - percentage *float64 - addpercentage *float64 - _limit *bool + card *int + addcard *int status *string - comment *string - created_at *time.Time - next *string - updated_at *time.Time + cp *int + addcp *int url *string + created_at *time.Time clearedFields map[string]struct{} + owner *int + clearedowner bool done bool - oldValue func(context.Context) (*Users, error) - predicates []predicate.Users + oldValue func(context.Context) (*Card, error) + predicates []predicate.Card } -var _ ent.Mutation = (*UsersMutation)(nil) +var _ ent.Mutation = (*CardMutation)(nil) -// usersOption allows management of the mutation configuration using functional options. -type usersOption func(*UsersMutation) +// cardOption allows management of the mutation configuration using functional options. +type cardOption func(*CardMutation) -// newUsersMutation creates new mutation for the Users entity. -func newUsersMutation(c config, op Op, opts ...usersOption) *UsersMutation { - m := &UsersMutation{ +// newCardMutation creates new mutation for the Card entity. +func newCardMutation(c config, op Op, opts ...cardOption) *CardMutation { + m := &CardMutation{ config: c, op: op, - typ: TypeUsers, + typ: TypeCard, clearedFields: make(map[string]struct{}), } for _, opt := range opts { @@ -84,20 +71,20 @@ func newUsersMutation(c config, op Op, opts ...usersOption) *UsersMutation { return m } -// withUsersID sets the ID field of the mutation. -func withUsersID(id int) usersOption { - return func(m *UsersMutation) { +// withCardID sets the ID field of the mutation. +func withCardID(id int) cardOption { + return func(m *CardMutation) { var ( err error once sync.Once - value *Users + value *Card ) - m.oldValue = func(ctx context.Context) (*Users, error) { + m.oldValue = func(ctx context.Context) (*Card, error) { once.Do(func() { if m.done { err = errors.New("querying old values post mutation is not allowed") } else { - value, err = m.Client().Users.Get(ctx, id) + value, err = m.Client().Card.Get(ctx, id) } }) return value, err @@ -106,10 +93,10 @@ func withUsersID(id int) usersOption { } } -// withUsers sets the old Users of the mutation. -func withUsers(node *Users) usersOption { - return func(m *UsersMutation) { - m.oldValue = func(context.Context) (*Users, error) { +// withCard sets the old Card of the mutation. +func withCard(node *Card) cardOption { + return func(m *CardMutation) { + m.oldValue = func(context.Context) (*Card, error) { return node, nil } m.id = &node.ID @@ -118,7 +105,7 @@ func withUsers(node *Users) usersOption { // 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 UsersMutation) Client() *Client { +func (m CardMutation) Client() *Client { client := &Client{config: m.config} client.init() return client @@ -126,7 +113,7 @@ func (m UsersMutation) Client() *Client { // Tx returns an `ent.Tx` for mutations that were executed in transactions; // it returns an error otherwise. -func (m UsersMutation) Tx() (*Tx, error) { +func (m CardMutation) Tx() (*Tx, error) { if _, ok := m.driver.(*txDriver); !ok { return nil, errors.New("ent: mutation is not running in a transaction") } @@ -137,7 +124,7 @@ func (m UsersMutation) Tx() (*Tx, error) { // 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 *UsersMutation) ID() (id int, exists bool) { +func (m *CardMutation) ID() (id int, exists bool) { if m.id == nil { return } @@ -148,7 +135,7 @@ func (m *UsersMutation) ID() (id int, exists bool) { // 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 *UsersMutation) IDs(ctx context.Context) ([]int, error) { +func (m *CardMutation) IDs(ctx context.Context) ([]int, error) { switch { case m.op.Is(OpUpdateOne | OpDeleteOne): id, exists := m.ID() @@ -157,783 +144,89 @@ func (m *UsersMutation) IDs(ctx context.Context) ([]int, error) { } fallthrough case m.op.Is(OpUpdate | OpDelete): - return m.Client().Users.Query().Where(m.predicates...).IDs(ctx) + return m.Client().Card.Query().Where(m.predicates...).IDs(ctx) default: return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op) } } -// SetUser sets the "user" field. -func (m *UsersMutation) SetUser(s string) { - m.user = &s +// SetCard sets the "card" field. +func (m *CardMutation) SetCard(i int) { + m.card = &i + m.addcard = nil } -// User returns the value of the "user" field in the mutation. -func (m *UsersMutation) User() (r string, exists bool) { - v := m.user +// Card returns the value of the "card" field in the mutation. +func (m *CardMutation) Card() (r int, exists bool) { + v := m.card if v == nil { return } return *v, true } -// OldUser returns the old "user" field's value of the Users entity. -// If the Users object wasn't provided to the builder, the object is fetched from the database. +// OldCard returns the old "card" field's value of the Card entity. +// If the Card 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 *UsersMutation) OldUser(ctx context.Context) (v string, err error) { +func (m *CardMutation) OldCard(ctx context.Context) (v int, err error) { if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldUser is only allowed on UpdateOne operations") + return v, errors.New("OldCard is only allowed on UpdateOne operations") } if m.id == nil || m.oldValue == nil { - return v, errors.New("OldUser requires an ID field in the mutation") + 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 OldUser: %w", err) + return v, fmt.Errorf("querying old value for OldCard: %w", err) } - return oldValue.User, nil + return oldValue.Card, nil } -// ResetUser resets all changes to the "user" field. -func (m *UsersMutation) ResetUser() { - m.user = nil -} - -// SetChara sets the "chara" field. -func (m *UsersMutation) SetChara(s string) { - m.chara = &s -} - -// Chara returns the value of the "chara" field in the mutation. -func (m *UsersMutation) Chara() (r string, exists bool) { - v := m.chara - if v == nil { - return - } - return *v, true -} - -// OldChara returns the old "chara" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldChara(ctx context.Context) (v string, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldChara is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldChara requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldChara: %w", err) - } - return oldValue.Chara, nil -} - -// ClearChara clears the value of the "chara" field. -func (m *UsersMutation) ClearChara() { - m.chara = nil - m.clearedFields[users.FieldChara] = struct{}{} -} - -// CharaCleared returns if the "chara" field was cleared in this mutation. -func (m *UsersMutation) CharaCleared() bool { - _, ok := m.clearedFields[users.FieldChara] - return ok -} - -// ResetChara resets all changes to the "chara" field. -func (m *UsersMutation) ResetChara() { - m.chara = nil - delete(m.clearedFields, users.FieldChara) -} - -// SetSkill sets the "skill" field. -func (m *UsersMutation) SetSkill(i int) { - m.skill = &i - m.addskill = nil -} - -// Skill returns the value of the "skill" field in the mutation. -func (m *UsersMutation) Skill() (r int, exists bool) { - v := m.skill - if v == nil { - return - } - return *v, true -} - -// OldSkill returns the old "skill" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldSkill(ctx context.Context) (v int, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldSkill is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldSkill requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldSkill: %w", err) - } - return oldValue.Skill, nil -} - -// AddSkill adds i to the "skill" field. -func (m *UsersMutation) AddSkill(i int) { - if m.addskill != nil { - *m.addskill += i +// AddCard adds i to the "card" field. +func (m *CardMutation) AddCard(i int) { + if m.addcard != nil { + *m.addcard += i } else { - m.addskill = &i + m.addcard = &i } } -// AddedSkill returns the value that was added to the "skill" field in this mutation. -func (m *UsersMutation) AddedSkill() (r int, exists bool) { - v := m.addskill +// AddedCard returns the value that was added to the "card" field in this mutation. +func (m *CardMutation) AddedCard() (r int, exists bool) { + v := m.addcard if v == nil { return } return *v, true } -// ClearSkill clears the value of the "skill" field. -func (m *UsersMutation) ClearSkill() { - m.skill = nil - m.addskill = nil - m.clearedFields[users.FieldSkill] = struct{}{} +// ClearCard clears the value of the "card" field. +func (m *CardMutation) ClearCard() { + m.card = nil + m.addcard = nil + m.clearedFields[card.FieldCard] = struct{}{} } -// SkillCleared returns if the "skill" field was cleared in this mutation. -func (m *UsersMutation) SkillCleared() bool { - _, ok := m.clearedFields[users.FieldSkill] +// CardCleared returns if the "card" field was cleared in this mutation. +func (m *CardMutation) CardCleared() bool { + _, ok := m.clearedFields[card.FieldCard] return ok } -// ResetSkill resets all changes to the "skill" field. -func (m *UsersMutation) ResetSkill() { - m.skill = nil - m.addskill = nil - delete(m.clearedFields, users.FieldSkill) -} - -// SetHp sets the "hp" field. -func (m *UsersMutation) SetHp(i int) { - m.hp = &i - m.addhp = nil -} - -// Hp returns the value of the "hp" field in the mutation. -func (m *UsersMutation) Hp() (r int, exists bool) { - v := m.hp - if v == nil { - return - } - return *v, true -} - -// OldHp returns the old "hp" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldHp(ctx context.Context) (v int, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldHp is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldHp requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldHp: %w", err) - } - return oldValue.Hp, nil -} - -// AddHp adds i to the "hp" field. -func (m *UsersMutation) AddHp(i int) { - if m.addhp != nil { - *m.addhp += i - } else { - m.addhp = &i - } -} - -// AddedHp returns the value that was added to the "hp" field in this mutation. -func (m *UsersMutation) AddedHp() (r int, exists bool) { - v := m.addhp - if v == nil { - return - } - return *v, true -} - -// ClearHp clears the value of the "hp" field. -func (m *UsersMutation) ClearHp() { - m.hp = nil - m.addhp = nil - m.clearedFields[users.FieldHp] = struct{}{} -} - -// HpCleared returns if the "hp" field was cleared in this mutation. -func (m *UsersMutation) HpCleared() bool { - _, ok := m.clearedFields[users.FieldHp] - return ok -} - -// ResetHp resets all changes to the "hp" field. -func (m *UsersMutation) ResetHp() { - m.hp = nil - m.addhp = nil - delete(m.clearedFields, users.FieldHp) -} - -// SetAttack sets the "attack" field. -func (m *UsersMutation) SetAttack(i int) { - m.attack = &i - m.addattack = nil -} - -// Attack returns the value of the "attack" field in the mutation. -func (m *UsersMutation) Attack() (r int, exists bool) { - v := m.attack - if v == nil { - return - } - return *v, true -} - -// OldAttack returns the old "attack" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldAttack(ctx context.Context) (v int, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldAttack is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldAttack requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldAttack: %w", err) - } - return oldValue.Attack, nil -} - -// AddAttack adds i to the "attack" field. -func (m *UsersMutation) AddAttack(i int) { - if m.addattack != nil { - *m.addattack += i - } else { - m.addattack = &i - } -} - -// AddedAttack returns the value that was added to the "attack" field in this mutation. -func (m *UsersMutation) AddedAttack() (r int, exists bool) { - v := m.addattack - if v == nil { - return - } - return *v, true -} - -// ClearAttack clears the value of the "attack" field. -func (m *UsersMutation) ClearAttack() { - m.attack = nil - m.addattack = nil - m.clearedFields[users.FieldAttack] = struct{}{} -} - -// AttackCleared returns if the "attack" field was cleared in this mutation. -func (m *UsersMutation) AttackCleared() bool { - _, ok := m.clearedFields[users.FieldAttack] - return ok -} - -// ResetAttack resets all changes to the "attack" field. -func (m *UsersMutation) ResetAttack() { - m.attack = nil - m.addattack = nil - delete(m.clearedFields, users.FieldAttack) -} - -// SetDefense sets the "defense" field. -func (m *UsersMutation) SetDefense(i int) { - m.defense = &i - m.adddefense = nil -} - -// Defense returns the value of the "defense" field in the mutation. -func (m *UsersMutation) Defense() (r int, exists bool) { - v := m.defense - if v == nil { - return - } - return *v, true -} - -// OldDefense returns the old "defense" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldDefense(ctx context.Context) (v int, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldDefense is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldDefense requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldDefense: %w", err) - } - return oldValue.Defense, nil -} - -// AddDefense adds i to the "defense" field. -func (m *UsersMutation) AddDefense(i int) { - if m.adddefense != nil { - *m.adddefense += i - } else { - m.adddefense = &i - } -} - -// AddedDefense returns the value that was added to the "defense" field in this mutation. -func (m *UsersMutation) AddedDefense() (r int, exists bool) { - v := m.adddefense - if v == nil { - return - } - return *v, true -} - -// ClearDefense clears the value of the "defense" field. -func (m *UsersMutation) ClearDefense() { - m.defense = nil - m.adddefense = nil - m.clearedFields[users.FieldDefense] = struct{}{} -} - -// DefenseCleared returns if the "defense" field was cleared in this mutation. -func (m *UsersMutation) DefenseCleared() bool { - _, ok := m.clearedFields[users.FieldDefense] - return ok -} - -// ResetDefense resets all changes to the "defense" field. -func (m *UsersMutation) ResetDefense() { - m.defense = nil - m.adddefense = nil - delete(m.clearedFields, users.FieldDefense) -} - -// SetCritical sets the "critical" field. -func (m *UsersMutation) SetCritical(i int) { - m.critical = &i - m.addcritical = nil -} - -// Critical returns the value of the "critical" field in the mutation. -func (m *UsersMutation) Critical() (r int, exists bool) { - v := m.critical - if v == nil { - return - } - return *v, true -} - -// OldCritical returns the old "critical" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldCritical(ctx context.Context) (v int, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldCritical is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldCritical requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldCritical: %w", err) - } - return oldValue.Critical, nil -} - -// AddCritical adds i to the "critical" field. -func (m *UsersMutation) AddCritical(i int) { - if m.addcritical != nil { - *m.addcritical += i - } else { - m.addcritical = &i - } -} - -// AddedCritical returns the value that was added to the "critical" field in this mutation. -func (m *UsersMutation) AddedCritical() (r int, exists bool) { - v := m.addcritical - if v == nil { - return - } - return *v, true -} - -// ClearCritical clears the value of the "critical" field. -func (m *UsersMutation) ClearCritical() { - m.critical = nil - m.addcritical = nil - m.clearedFields[users.FieldCritical] = struct{}{} -} - -// CriticalCleared returns if the "critical" field was cleared in this mutation. -func (m *UsersMutation) CriticalCleared() bool { - _, ok := m.clearedFields[users.FieldCritical] - return ok -} - -// ResetCritical resets all changes to the "critical" field. -func (m *UsersMutation) ResetCritical() { - m.critical = nil - m.addcritical = nil - delete(m.clearedFields, users.FieldCritical) -} - -// SetBattle sets the "battle" field. -func (m *UsersMutation) SetBattle(i int) { - m.battle = &i - m.addbattle = nil -} - -// Battle returns the value of the "battle" field in the mutation. -func (m *UsersMutation) Battle() (r int, exists bool) { - v := m.battle - if v == nil { - return - } - return *v, true -} - -// OldBattle returns the old "battle" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldBattle(ctx context.Context) (v int, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldBattle is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldBattle requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldBattle: %w", err) - } - return oldValue.Battle, nil -} - -// AddBattle adds i to the "battle" field. -func (m *UsersMutation) AddBattle(i int) { - if m.addbattle != nil { - *m.addbattle += i - } else { - m.addbattle = &i - } -} - -// AddedBattle returns the value that was added to the "battle" field in this mutation. -func (m *UsersMutation) AddedBattle() (r int, exists bool) { - v := m.addbattle - if v == nil { - return - } - return *v, true -} - -// ClearBattle clears the value of the "battle" field. -func (m *UsersMutation) ClearBattle() { - m.battle = nil - m.addbattle = nil - m.clearedFields[users.FieldBattle] = struct{}{} -} - -// BattleCleared returns if the "battle" field was cleared in this mutation. -func (m *UsersMutation) BattleCleared() bool { - _, ok := m.clearedFields[users.FieldBattle] - return ok -} - -// ResetBattle resets all changes to the "battle" field. -func (m *UsersMutation) ResetBattle() { - m.battle = nil - m.addbattle = nil - delete(m.clearedFields, users.FieldBattle) -} - -// SetWin sets the "win" field. -func (m *UsersMutation) SetWin(i int) { - m.win = &i - m.addwin = nil -} - -// Win returns the value of the "win" field in the mutation. -func (m *UsersMutation) Win() (r int, exists bool) { - v := m.win - if v == nil { - return - } - return *v, true -} - -// OldWin returns the old "win" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldWin(ctx context.Context) (v int, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldWin is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldWin requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldWin: %w", err) - } - return oldValue.Win, nil -} - -// AddWin adds i to the "win" field. -func (m *UsersMutation) AddWin(i int) { - if m.addwin != nil { - *m.addwin += i - } else { - m.addwin = &i - } -} - -// AddedWin returns the value that was added to the "win" field in this mutation. -func (m *UsersMutation) AddedWin() (r int, exists bool) { - v := m.addwin - if v == nil { - return - } - return *v, true -} - -// ClearWin clears the value of the "win" field. -func (m *UsersMutation) ClearWin() { - m.win = nil - m.addwin = nil - m.clearedFields[users.FieldWin] = struct{}{} -} - -// WinCleared returns if the "win" field was cleared in this mutation. -func (m *UsersMutation) WinCleared() bool { - _, ok := m.clearedFields[users.FieldWin] - return ok -} - -// ResetWin resets all changes to the "win" field. -func (m *UsersMutation) ResetWin() { - m.win = nil - m.addwin = nil - delete(m.clearedFields, users.FieldWin) -} - -// SetDay sets the "day" field. -func (m *UsersMutation) SetDay(i int) { - m.day = &i - m.addday = nil -} - -// Day returns the value of the "day" field in the mutation. -func (m *UsersMutation) Day() (r int, exists bool) { - v := m.day - if v == nil { - return - } - return *v, true -} - -// OldDay returns the old "day" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldDay(ctx context.Context) (v int, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldDay is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldDay requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldDay: %w", err) - } - return oldValue.Day, nil -} - -// AddDay adds i to the "day" field. -func (m *UsersMutation) AddDay(i int) { - if m.addday != nil { - *m.addday += i - } else { - m.addday = &i - } -} - -// AddedDay returns the value that was added to the "day" field in this mutation. -func (m *UsersMutation) AddedDay() (r int, exists bool) { - v := m.addday - if v == nil { - return - } - return *v, true -} - -// ClearDay clears the value of the "day" field. -func (m *UsersMutation) ClearDay() { - m.day = nil - m.addday = nil - m.clearedFields[users.FieldDay] = struct{}{} -} - -// DayCleared returns if the "day" field was cleared in this mutation. -func (m *UsersMutation) DayCleared() bool { - _, ok := m.clearedFields[users.FieldDay] - return ok -} - -// ResetDay resets all changes to the "day" field. -func (m *UsersMutation) ResetDay() { - m.day = nil - m.addday = nil - delete(m.clearedFields, users.FieldDay) -} - -// SetPercentage sets the "percentage" field. -func (m *UsersMutation) SetPercentage(f float64) { - m.percentage = &f - m.addpercentage = nil -} - -// Percentage returns the value of the "percentage" field in the mutation. -func (m *UsersMutation) Percentage() (r float64, exists bool) { - v := m.percentage - if v == nil { - return - } - return *v, true -} - -// OldPercentage returns the old "percentage" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldPercentage(ctx context.Context) (v float64, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldPercentage is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldPercentage requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldPercentage: %w", err) - } - return oldValue.Percentage, nil -} - -// AddPercentage adds f to the "percentage" field. -func (m *UsersMutation) AddPercentage(f float64) { - if m.addpercentage != nil { - *m.addpercentage += f - } else { - m.addpercentage = &f - } -} - -// AddedPercentage returns the value that was added to the "percentage" field in this mutation. -func (m *UsersMutation) AddedPercentage() (r float64, exists bool) { - v := m.addpercentage - if v == nil { - return - } - return *v, true -} - -// ClearPercentage clears the value of the "percentage" field. -func (m *UsersMutation) ClearPercentage() { - m.percentage = nil - m.addpercentage = nil - m.clearedFields[users.FieldPercentage] = struct{}{} -} - -// PercentageCleared returns if the "percentage" field was cleared in this mutation. -func (m *UsersMutation) PercentageCleared() bool { - _, ok := m.clearedFields[users.FieldPercentage] - return ok -} - -// ResetPercentage resets all changes to the "percentage" field. -func (m *UsersMutation) ResetPercentage() { - m.percentage = nil - m.addpercentage = nil - delete(m.clearedFields, users.FieldPercentage) -} - -// SetLimit sets the "limit" field. -func (m *UsersMutation) SetLimit(b bool) { - m._limit = &b -} - -// Limit returns the value of the "limit" field in the mutation. -func (m *UsersMutation) 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 Users entity. -// If the Users 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 *UsersMutation) 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 *UsersMutation) ClearLimit() { - m._limit = nil - m.clearedFields[users.FieldLimit] = struct{}{} -} - -// LimitCleared returns if the "limit" field was cleared in this mutation. -func (m *UsersMutation) LimitCleared() bool { - _, ok := m.clearedFields[users.FieldLimit] - return ok -} - -// ResetLimit resets all changes to the "limit" field. -func (m *UsersMutation) ResetLimit() { - m._limit = nil - delete(m.clearedFields, users.FieldLimit) +// ResetCard resets all changes to the "card" field. +func (m *CardMutation) ResetCard() { + m.card = nil + m.addcard = nil + delete(m.clearedFields, card.FieldCard) } // SetStatus sets the "status" field. -func (m *UsersMutation) SetStatus(s string) { +func (m *CardMutation) SetStatus(s string) { m.status = &s } // Status returns the value of the "status" field in the mutation. -func (m *UsersMutation) Status() (r string, exists bool) { +func (m *CardMutation) Status() (r string, exists bool) { v := m.status if v == nil { return @@ -941,10 +234,10 @@ func (m *UsersMutation) Status() (r string, exists bool) { return *v, true } -// OldStatus returns the old "status" field's value of the Users entity. -// If the Users object wasn't provided to the builder, the object is fetched from the database. +// OldStatus returns the old "status" field's value of the Card entity. +// If the Card 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 *UsersMutation) OldStatus(ctx context.Context) (v string, err error) { +func (m *CardMutation) OldStatus(ctx context.Context) (v string, err error) { if !m.op.Is(OpUpdateOne) { return v, errors.New("OldStatus is only allowed on UpdateOne operations") } @@ -959,226 +252,100 @@ func (m *UsersMutation) OldStatus(ctx context.Context) (v string, err error) { } // ClearStatus clears the value of the "status" field. -func (m *UsersMutation) ClearStatus() { +func (m *CardMutation) ClearStatus() { m.status = nil - m.clearedFields[users.FieldStatus] = struct{}{} + m.clearedFields[card.FieldStatus] = struct{}{} } // StatusCleared returns if the "status" field was cleared in this mutation. -func (m *UsersMutation) StatusCleared() bool { - _, ok := m.clearedFields[users.FieldStatus] +func (m *CardMutation) StatusCleared() bool { + _, ok := m.clearedFields[card.FieldStatus] return ok } // ResetStatus resets all changes to the "status" field. -func (m *UsersMutation) ResetStatus() { +func (m *CardMutation) ResetStatus() { m.status = nil - delete(m.clearedFields, users.FieldStatus) + delete(m.clearedFields, card.FieldStatus) } -// SetComment sets the "comment" field. -func (m *UsersMutation) SetComment(s string) { - m.comment = &s +// SetCp sets the "cp" field. +func (m *CardMutation) SetCp(i int) { + m.cp = &i + m.addcp = nil } -// Comment returns the value of the "comment" field in the mutation. -func (m *UsersMutation) Comment() (r string, exists bool) { - v := m.comment +// Cp returns the value of the "cp" field in the mutation. +func (m *CardMutation) Cp() (r int, exists bool) { + v := m.cp if v == nil { return } return *v, true } -// OldComment returns the old "comment" field's value of the Users entity. -// If the Users object wasn't provided to the builder, the object is fetched from the database. +// OldCp returns the old "cp" field's value of the Card entity. +// If the Card 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 *UsersMutation) OldComment(ctx context.Context) (v string, err error) { +func (m *CardMutation) OldCp(ctx context.Context) (v int, err error) { if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldComment is only allowed on UpdateOne operations") + return v, errors.New("OldCp is only allowed on UpdateOne operations") } if m.id == nil || m.oldValue == nil { - return v, errors.New("OldComment requires an ID field in the mutation") + 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 OldComment: %w", err) + return v, fmt.Errorf("querying old value for OldCp: %w", err) } - return oldValue.Comment, nil + return oldValue.Cp, nil } -// ClearComment clears the value of the "comment" field. -func (m *UsersMutation) ClearComment() { - m.comment = nil - m.clearedFields[users.FieldComment] = struct{}{} +// AddCp adds i to the "cp" field. +func (m *CardMutation) AddCp(i int) { + if m.addcp != nil { + *m.addcp += i + } else { + m.addcp = &i + } } -// CommentCleared returns if the "comment" field was cleared in this mutation. -func (m *UsersMutation) CommentCleared() bool { - _, ok := m.clearedFields[users.FieldComment] - return ok -} - -// ResetComment resets all changes to the "comment" field. -func (m *UsersMutation) ResetComment() { - m.comment = nil - delete(m.clearedFields, users.FieldComment) -} - -// SetCreatedAt sets the "created_at" field. -func (m *UsersMutation) SetCreatedAt(t time.Time) { - m.created_at = &t -} - -// CreatedAt returns the value of the "created_at" field in the mutation. -func (m *UsersMutation) CreatedAt() (r time.Time, exists bool) { - v := m.created_at +// AddedCp returns the value that was added to the "cp" field in this mutation. +func (m *CardMutation) AddedCp() (r int, exists bool) { + v := m.addcp if v == nil { return } return *v, true } -// OldCreatedAt returns the old "created_at" field's value of the Users entity. -// If the Users 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 *UsersMutation) 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 +// ClearCp clears the value of the "cp" field. +func (m *CardMutation) ClearCp() { + m.cp = nil + m.addcp = nil + m.clearedFields[card.FieldCp] = struct{}{} } -// ClearCreatedAt clears the value of the "created_at" field. -func (m *UsersMutation) ClearCreatedAt() { - m.created_at = nil - m.clearedFields[users.FieldCreatedAt] = struct{}{} -} - -// CreatedAtCleared returns if the "created_at" field was cleared in this mutation. -func (m *UsersMutation) CreatedAtCleared() bool { - _, ok := m.clearedFields[users.FieldCreatedAt] +// CpCleared returns if the "cp" field was cleared in this mutation. +func (m *CardMutation) CpCleared() bool { + _, ok := m.clearedFields[card.FieldCp] return ok } -// ResetCreatedAt resets all changes to the "created_at" field. -func (m *UsersMutation) ResetCreatedAt() { - m.created_at = nil - delete(m.clearedFields, users.FieldCreatedAt) -} - -// SetNext sets the "next" field. -func (m *UsersMutation) SetNext(s string) { - m.next = &s -} - -// Next returns the value of the "next" field in the mutation. -func (m *UsersMutation) Next() (r string, exists bool) { - v := m.next - if v == nil { - return - } - return *v, true -} - -// OldNext returns the old "next" field's value of the Users entity. -// If the Users 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 *UsersMutation) OldNext(ctx context.Context) (v string, err error) { - if !m.op.Is(OpUpdateOne) { - return v, errors.New("OldNext is only allowed on UpdateOne operations") - } - if m.id == nil || m.oldValue == nil { - return v, errors.New("OldNext requires an ID field in the mutation") - } - oldValue, err := m.oldValue(ctx) - if err != nil { - return v, fmt.Errorf("querying old value for OldNext: %w", err) - } - return oldValue.Next, nil -} - -// ClearNext clears the value of the "next" field. -func (m *UsersMutation) ClearNext() { - m.next = nil - m.clearedFields[users.FieldNext] = struct{}{} -} - -// NextCleared returns if the "next" field was cleared in this mutation. -func (m *UsersMutation) NextCleared() bool { - _, ok := m.clearedFields[users.FieldNext] - return ok -} - -// ResetNext resets all changes to the "next" field. -func (m *UsersMutation) ResetNext() { - m.next = nil - delete(m.clearedFields, users.FieldNext) -} - -// SetUpdatedAt sets the "updated_at" field. -func (m *UsersMutation) SetUpdatedAt(t time.Time) { - m.updated_at = &t -} - -// UpdatedAt returns the value of the "updated_at" field in the mutation. -func (m *UsersMutation) 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 Users entity. -// If the Users 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 *UsersMutation) 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 *UsersMutation) ClearUpdatedAt() { - m.updated_at = nil - m.clearedFields[users.FieldUpdatedAt] = struct{}{} -} - -// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation. -func (m *UsersMutation) UpdatedAtCleared() bool { - _, ok := m.clearedFields[users.FieldUpdatedAt] - return ok -} - -// ResetUpdatedAt resets all changes to the "updated_at" field. -func (m *UsersMutation) ResetUpdatedAt() { - m.updated_at = nil - delete(m.clearedFields, users.FieldUpdatedAt) +// ResetCp resets all changes to the "cp" field. +func (m *CardMutation) ResetCp() { + m.cp = nil + m.addcp = nil + delete(m.clearedFields, card.FieldCp) } // SetURL sets the "url" field. -func (m *UsersMutation) SetURL(s string) { +func (m *CardMutation) SetURL(s string) { m.url = &s } // URL returns the value of the "url" field in the mutation. -func (m *UsersMutation) URL() (r string, exists bool) { +func (m *CardMutation) URL() (r string, exists bool) { v := m.url if v == nil { return @@ -1186,10 +353,10 @@ func (m *UsersMutation) URL() (r string, exists bool) { return *v, true } -// OldURL returns the old "url" field's value of the Users entity. -// If the Users object wasn't provided to the builder, the object is fetched from the database. +// OldURL returns the old "url" field's value of the Card entity. +// If the Card 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 *UsersMutation) OldURL(ctx context.Context) (v string, err error) { +func (m *CardMutation) OldURL(ctx context.Context) (v string, err error) { if !m.op.Is(OpUpdateOne) { return v, errors.New("OldURL is only allowed on UpdateOne operations") } @@ -1204,96 +371,160 @@ func (m *UsersMutation) OldURL(ctx context.Context) (v string, err error) { } // ClearURL clears the value of the "url" field. -func (m *UsersMutation) ClearURL() { +func (m *CardMutation) ClearURL() { m.url = nil - m.clearedFields[users.FieldURL] = struct{}{} + m.clearedFields[card.FieldURL] = struct{}{} } // URLCleared returns if the "url" field was cleared in this mutation. -func (m *UsersMutation) URLCleared() bool { - _, ok := m.clearedFields[users.FieldURL] +func (m *CardMutation) URLCleared() bool { + _, ok := m.clearedFields[card.FieldURL] return ok } // ResetURL resets all changes to the "url" field. -func (m *UsersMutation) ResetURL() { +func (m *CardMutation) ResetURL() { m.url = nil - delete(m.clearedFields, users.FieldURL) + delete(m.clearedFields, card.FieldURL) } -// Where appends a list predicates to the UsersMutation builder. -func (m *UsersMutation) Where(ps ...predicate.Users) { +// SetCreatedAt sets the "created_at" field. +func (m *CardMutation) SetCreatedAt(t time.Time) { + m.created_at = &t +} + +// CreatedAt returns the value of the "created_at" field in the mutation. +func (m *CardMutation) 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 Card entity. +// If the Card 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 *CardMutation) 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 *CardMutation) ClearCreatedAt() { + m.created_at = nil + m.clearedFields[card.FieldCreatedAt] = struct{}{} +} + +// CreatedAtCleared returns if the "created_at" field was cleared in this mutation. +func (m *CardMutation) CreatedAtCleared() bool { + _, ok := m.clearedFields[card.FieldCreatedAt] + return ok +} + +// ResetCreatedAt resets all changes to the "created_at" field. +func (m *CardMutation) ResetCreatedAt() { + m.created_at = nil + delete(m.clearedFields, card.FieldCreatedAt) +} + +// SetOwnerID sets the "owner" edge to the User entity by id. +func (m *CardMutation) SetOwnerID(id int) { + m.owner = &id +} + +// ClearOwner clears the "owner" edge to the User entity. +func (m *CardMutation) ClearOwner() { + m.clearedowner = true +} + +// OwnerCleared reports if the "owner" edge to the User entity was cleared. +func (m *CardMutation) OwnerCleared() bool { + return m.clearedowner +} + +// OwnerID returns the "owner" edge ID in the mutation. +func (m *CardMutation) 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 *CardMutation) OwnerIDs() (ids []int) { + if id := m.owner; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetOwner resets all changes to the "owner" edge. +func (m *CardMutation) ResetOwner() { + m.owner = nil + m.clearedowner = false +} + +// Where appends a list predicates to the CardMutation builder. +func (m *CardMutation) Where(ps ...predicate.Card) { m.predicates = append(m.predicates, ps...) } +// WhereP appends storage-level predicates to the CardMutation builder. Using this method, +// users can use type-assertion to append predicates that do not depend on any generated package. +func (m *CardMutation) WhereP(ps ...func(*sql.Selector)) { + p := make([]predicate.Card, len(ps)) + for i := range ps { + p[i] = ps[i] + } + m.Where(p...) +} + // Op returns the operation name. -func (m *UsersMutation) Op() Op { +func (m *CardMutation) Op() Op { return m.op } -// Type returns the node type of this mutation (Users). -func (m *UsersMutation) Type() string { +// SetOp allows setting the mutation operation. +func (m *CardMutation) SetOp(op Op) { + m.op = op +} + +// Type returns the node type of this mutation (Card). +func (m *CardMutation) 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 *UsersMutation) Fields() []string { - fields := make([]string, 0, 18) - if m.user != nil { - fields = append(fields, users.FieldUser) - } - if m.chara != nil { - fields = append(fields, users.FieldChara) - } - if m.skill != nil { - fields = append(fields, users.FieldSkill) - } - if m.hp != nil { - fields = append(fields, users.FieldHp) - } - if m.attack != nil { - fields = append(fields, users.FieldAttack) - } - if m.defense != nil { - fields = append(fields, users.FieldDefense) - } - if m.critical != nil { - fields = append(fields, users.FieldCritical) - } - if m.battle != nil { - fields = append(fields, users.FieldBattle) - } - if m.win != nil { - fields = append(fields, users.FieldWin) - } - if m.day != nil { - fields = append(fields, users.FieldDay) - } - if m.percentage != nil { - fields = append(fields, users.FieldPercentage) - } - if m._limit != nil { - fields = append(fields, users.FieldLimit) +func (m *CardMutation) Fields() []string { + fields := make([]string, 0, 5) + if m.card != nil { + fields = append(fields, card.FieldCard) } if m.status != nil { - fields = append(fields, users.FieldStatus) + fields = append(fields, card.FieldStatus) } - if m.comment != nil { - fields = append(fields, users.FieldComment) - } - if m.created_at != nil { - fields = append(fields, users.FieldCreatedAt) - } - if m.next != nil { - fields = append(fields, users.FieldNext) - } - if m.updated_at != nil { - fields = append(fields, users.FieldUpdatedAt) + if m.cp != nil { + fields = append(fields, card.FieldCp) } if m.url != nil { - fields = append(fields, users.FieldURL) + fields = append(fields, card.FieldURL) + } + if m.created_at != nil { + fields = append(fields, card.FieldCreatedAt) } return fields } @@ -1301,44 +532,18 @@ func (m *UsersMutation) Fields() []string { // 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 *UsersMutation) Field(name string) (ent.Value, bool) { +func (m *CardMutation) Field(name string) (ent.Value, bool) { switch name { - case users.FieldUser: - return m.User() - case users.FieldChara: - return m.Chara() - case users.FieldSkill: - return m.Skill() - case users.FieldHp: - return m.Hp() - case users.FieldAttack: - return m.Attack() - case users.FieldDefense: - return m.Defense() - case users.FieldCritical: - return m.Critical() - case users.FieldBattle: - return m.Battle() - case users.FieldWin: - return m.Win() - case users.FieldDay: - return m.Day() - case users.FieldPercentage: - return m.Percentage() - case users.FieldLimit: - return m.Limit() - case users.FieldStatus: + case card.FieldCard: + return m.Card() + case card.FieldStatus: return m.Status() - case users.FieldComment: - return m.Comment() - case users.FieldCreatedAt: - return m.CreatedAt() - case users.FieldNext: - return m.Next() - case users.FieldUpdatedAt: - return m.UpdatedAt() - case users.FieldURL: + case card.FieldCp: + return m.Cp() + case card.FieldURL: return m.URL() + case card.FieldCreatedAt: + return m.CreatedAt() } return nil, false } @@ -1346,213 +551,75 @@ func (m *UsersMutation) Field(name string) (ent.Value, bool) { // 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 *UsersMutation) OldField(ctx context.Context, name string) (ent.Value, error) { +func (m *CardMutation) OldField(ctx context.Context, name string) (ent.Value, error) { switch name { - case users.FieldUser: - return m.OldUser(ctx) - case users.FieldChara: - return m.OldChara(ctx) - case users.FieldSkill: - return m.OldSkill(ctx) - case users.FieldHp: - return m.OldHp(ctx) - case users.FieldAttack: - return m.OldAttack(ctx) - case users.FieldDefense: - return m.OldDefense(ctx) - case users.FieldCritical: - return m.OldCritical(ctx) - case users.FieldBattle: - return m.OldBattle(ctx) - case users.FieldWin: - return m.OldWin(ctx) - case users.FieldDay: - return m.OldDay(ctx) - case users.FieldPercentage: - return m.OldPercentage(ctx) - case users.FieldLimit: - return m.OldLimit(ctx) - case users.FieldStatus: + case card.FieldCard: + return m.OldCard(ctx) + case card.FieldStatus: return m.OldStatus(ctx) - case users.FieldComment: - return m.OldComment(ctx) - case users.FieldCreatedAt: - return m.OldCreatedAt(ctx) - case users.FieldNext: - return m.OldNext(ctx) - case users.FieldUpdatedAt: - return m.OldUpdatedAt(ctx) - case users.FieldURL: + case card.FieldCp: + return m.OldCp(ctx) + case card.FieldURL: return m.OldURL(ctx) + case card.FieldCreatedAt: + return m.OldCreatedAt(ctx) } - return nil, fmt.Errorf("unknown Users field %s", name) + return nil, fmt.Errorf("unknown Card 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 *UsersMutation) SetField(name string, value ent.Value) error { +func (m *CardMutation) SetField(name string, value ent.Value) error { switch name { - case users.FieldUser: - v, ok := value.(string) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetUser(v) - return nil - case users.FieldChara: - v, ok := value.(string) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetChara(v) - return nil - case users.FieldSkill: + case card.FieldCard: v, ok := value.(int) if !ok { return fmt.Errorf("unexpected type %T for field %s", value, name) } - m.SetSkill(v) + m.SetCard(v) return nil - case users.FieldHp: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetHp(v) - return nil - case users.FieldAttack: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetAttack(v) - return nil - case users.FieldDefense: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetDefense(v) - return nil - case users.FieldCritical: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetCritical(v) - return nil - case users.FieldBattle: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetBattle(v) - return nil - case users.FieldWin: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetWin(v) - return nil - case users.FieldDay: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetDay(v) - return nil - case users.FieldPercentage: - v, ok := value.(float64) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetPercentage(v) - return nil - case users.FieldLimit: - v, ok := value.(bool) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetLimit(v) - return nil - case users.FieldStatus: + case card.FieldStatus: v, ok := value.(string) if !ok { return fmt.Errorf("unexpected type %T for field %s", value, name) } m.SetStatus(v) return nil - case users.FieldComment: - v, ok := value.(string) + case card.FieldCp: + v, ok := value.(int) if !ok { return fmt.Errorf("unexpected type %T for field %s", value, name) } - m.SetComment(v) + m.SetCp(v) return nil - case users.FieldCreatedAt: - v, ok := value.(time.Time) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetCreatedAt(v) - return nil - case users.FieldNext: - v, ok := value.(string) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.SetNext(v) - return nil - case users.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 users.FieldURL: + case card.FieldURL: v, ok := value.(string) if !ok { return fmt.Errorf("unexpected type %T for field %s", value, name) } m.SetURL(v) return nil + case card.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 Users field %s", name) + return fmt.Errorf("unknown Card field %s", name) } // AddedFields returns all numeric fields that were incremented/decremented during // this mutation. -func (m *UsersMutation) AddedFields() []string { +func (m *CardMutation) AddedFields() []string { var fields []string - if m.addskill != nil { - fields = append(fields, users.FieldSkill) + if m.addcard != nil { + fields = append(fields, card.FieldCard) } - if m.addhp != nil { - fields = append(fields, users.FieldHp) - } - if m.addattack != nil { - fields = append(fields, users.FieldAttack) - } - if m.adddefense != nil { - fields = append(fields, users.FieldDefense) - } - if m.addcritical != nil { - fields = append(fields, users.FieldCritical) - } - if m.addbattle != nil { - fields = append(fields, users.FieldBattle) - } - if m.addwin != nil { - fields = append(fields, users.FieldWin) - } - if m.addday != nil { - fields = append(fields, users.FieldDay) - } - if m.addpercentage != nil { - fields = append(fields, users.FieldPercentage) + if m.addcp != nil { + fields = append(fields, card.FieldCp) } return fields } @@ -1560,26 +627,12 @@ func (m *UsersMutation) AddedFields() []string { // 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 *UsersMutation) AddedField(name string) (ent.Value, bool) { +func (m *CardMutation) AddedField(name string) (ent.Value, bool) { switch name { - case users.FieldSkill: - return m.AddedSkill() - case users.FieldHp: - return m.AddedHp() - case users.FieldAttack: - return m.AddedAttack() - case users.FieldDefense: - return m.AddedDefense() - case users.FieldCritical: - return m.AddedCritical() - case users.FieldBattle: - return m.AddedBattle() - case users.FieldWin: - return m.AddedWin() - case users.FieldDay: - return m.AddedDay() - case users.FieldPercentage: - return m.AddedPercentage() + case card.FieldCard: + return m.AddedCard() + case card.FieldCp: + return m.AddedCp() } return nil, false } @@ -1587,305 +640,1231 @@ func (m *UsersMutation) AddedField(name string) (ent.Value, bool) { // 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 *UsersMutation) AddField(name string, value ent.Value) error { +func (m *CardMutation) AddField(name string, value ent.Value) error { switch name { - case users.FieldSkill: + case card.FieldCard: v, ok := value.(int) if !ok { return fmt.Errorf("unexpected type %T for field %s", value, name) } - m.AddSkill(v) + m.AddCard(v) return nil - case users.FieldHp: + case card.FieldCp: v, ok := value.(int) if !ok { return fmt.Errorf("unexpected type %T for field %s", value, name) } - m.AddHp(v) - return nil - case users.FieldAttack: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.AddAttack(v) - return nil - case users.FieldDefense: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.AddDefense(v) - return nil - case users.FieldCritical: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.AddCritical(v) - return nil - case users.FieldBattle: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.AddBattle(v) - return nil - case users.FieldWin: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.AddWin(v) - return nil - case users.FieldDay: - v, ok := value.(int) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.AddDay(v) - return nil - case users.FieldPercentage: - v, ok := value.(float64) - if !ok { - return fmt.Errorf("unexpected type %T for field %s", value, name) - } - m.AddPercentage(v) + m.AddCp(v) return nil } - return fmt.Errorf("unknown Users numeric field %s", name) + return fmt.Errorf("unknown Card numeric field %s", name) } // ClearedFields returns all nullable fields that were cleared during this // mutation. -func (m *UsersMutation) ClearedFields() []string { +func (m *CardMutation) ClearedFields() []string { var fields []string - if m.FieldCleared(users.FieldChara) { - fields = append(fields, users.FieldChara) + if m.FieldCleared(card.FieldCard) { + fields = append(fields, card.FieldCard) } - if m.FieldCleared(users.FieldSkill) { - fields = append(fields, users.FieldSkill) + if m.FieldCleared(card.FieldStatus) { + fields = append(fields, card.FieldStatus) } - if m.FieldCleared(users.FieldHp) { - fields = append(fields, users.FieldHp) + if m.FieldCleared(card.FieldCp) { + fields = append(fields, card.FieldCp) } - if m.FieldCleared(users.FieldAttack) { - fields = append(fields, users.FieldAttack) + if m.FieldCleared(card.FieldURL) { + fields = append(fields, card.FieldURL) } - if m.FieldCleared(users.FieldDefense) { - fields = append(fields, users.FieldDefense) - } - if m.FieldCleared(users.FieldCritical) { - fields = append(fields, users.FieldCritical) - } - if m.FieldCleared(users.FieldBattle) { - fields = append(fields, users.FieldBattle) - } - if m.FieldCleared(users.FieldWin) { - fields = append(fields, users.FieldWin) - } - if m.FieldCleared(users.FieldDay) { - fields = append(fields, users.FieldDay) - } - if m.FieldCleared(users.FieldPercentage) { - fields = append(fields, users.FieldPercentage) - } - if m.FieldCleared(users.FieldLimit) { - fields = append(fields, users.FieldLimit) - } - if m.FieldCleared(users.FieldStatus) { - fields = append(fields, users.FieldStatus) - } - if m.FieldCleared(users.FieldComment) { - fields = append(fields, users.FieldComment) - } - if m.FieldCleared(users.FieldCreatedAt) { - fields = append(fields, users.FieldCreatedAt) - } - if m.FieldCleared(users.FieldNext) { - fields = append(fields, users.FieldNext) - } - if m.FieldCleared(users.FieldUpdatedAt) { - fields = append(fields, users.FieldUpdatedAt) - } - if m.FieldCleared(users.FieldURL) { - fields = append(fields, users.FieldURL) + if m.FieldCleared(card.FieldCreatedAt) { + fields = append(fields, card.FieldCreatedAt) } return fields } // FieldCleared returns a boolean indicating if a field with the given name was // cleared in this mutation. -func (m *UsersMutation) FieldCleared(name string) bool { +func (m *CardMutation) 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 *UsersMutation) ClearField(name string) error { +func (m *CardMutation) ClearField(name string) error { switch name { - case users.FieldChara: - m.ClearChara() + case card.FieldCard: + m.ClearCard() return nil - case users.FieldSkill: - m.ClearSkill() - return nil - case users.FieldHp: - m.ClearHp() - return nil - case users.FieldAttack: - m.ClearAttack() - return nil - case users.FieldDefense: - m.ClearDefense() - return nil - case users.FieldCritical: - m.ClearCritical() - return nil - case users.FieldBattle: - m.ClearBattle() - return nil - case users.FieldWin: - m.ClearWin() - return nil - case users.FieldDay: - m.ClearDay() - return nil - case users.FieldPercentage: - m.ClearPercentage() - return nil - case users.FieldLimit: - m.ClearLimit() - return nil - case users.FieldStatus: + case card.FieldStatus: m.ClearStatus() return nil - case users.FieldComment: - m.ClearComment() + case card.FieldCp: + m.ClearCp() return nil - case users.FieldCreatedAt: - m.ClearCreatedAt() - return nil - case users.FieldNext: - m.ClearNext() - return nil - case users.FieldUpdatedAt: - m.ClearUpdatedAt() - return nil - case users.FieldURL: + case card.FieldURL: m.ClearURL() return nil + case card.FieldCreatedAt: + m.ClearCreatedAt() + return nil } - return fmt.Errorf("unknown Users nullable field %s", name) + return fmt.Errorf("unknown Card 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 *UsersMutation) ResetField(name string) error { +func (m *CardMutation) ResetField(name string) error { switch name { - case users.FieldUser: - m.ResetUser() + case card.FieldCard: + m.ResetCard() return nil - case users.FieldChara: - m.ResetChara() - return nil - case users.FieldSkill: - m.ResetSkill() - return nil - case users.FieldHp: - m.ResetHp() - return nil - case users.FieldAttack: - m.ResetAttack() - return nil - case users.FieldDefense: - m.ResetDefense() - return nil - case users.FieldCritical: - m.ResetCritical() - return nil - case users.FieldBattle: - m.ResetBattle() - return nil - case users.FieldWin: - m.ResetWin() - return nil - case users.FieldDay: - m.ResetDay() - return nil - case users.FieldPercentage: - m.ResetPercentage() - return nil - case users.FieldLimit: - m.ResetLimit() - return nil - case users.FieldStatus: + case card.FieldStatus: m.ResetStatus() return nil - case users.FieldComment: - m.ResetComment() + case card.FieldCp: + m.ResetCp() return nil - case users.FieldCreatedAt: - m.ResetCreatedAt() - return nil - case users.FieldNext: - m.ResetNext() - return nil - case users.FieldUpdatedAt: - m.ResetUpdatedAt() - return nil - case users.FieldURL: + case card.FieldURL: m.ResetURL() return nil + case card.FieldCreatedAt: + m.ResetCreatedAt() + return nil } - return fmt.Errorf("unknown Users field %s", name) + return fmt.Errorf("unknown Card field %s", name) } // AddedEdges returns all edge names that were set/added in this mutation. -func (m *UsersMutation) AddedEdges() []string { - edges := make([]string, 0, 0) +func (m *CardMutation) AddedEdges() []string { + edges := make([]string, 0, 1) + if m.owner != nil { + edges = append(edges, card.EdgeOwner) + } return edges } // AddedIDs returns all IDs (to other nodes) that were added for the given edge // name in this mutation. -func (m *UsersMutation) AddedIDs(name string) []ent.Value { +func (m *CardMutation) AddedIDs(name string) []ent.Value { + switch name { + case card.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 *UsersMutation) RemovedEdges() []string { - edges := make([]string, 0, 0) +func (m *CardMutation) 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 *UsersMutation) RemovedIDs(name string) []ent.Value { +func (m *CardMutation) RemovedIDs(name string) []ent.Value { return nil } // ClearedEdges returns all edge names that were cleared in this mutation. -func (m *UsersMutation) ClearedEdges() []string { - edges := make([]string, 0, 0) +func (m *CardMutation) ClearedEdges() []string { + edges := make([]string, 0, 1) + if m.clearedowner { + edges = append(edges, card.EdgeOwner) + } return edges } // EdgeCleared returns a boolean which indicates if the edge with the given name // was cleared in this mutation. -func (m *UsersMutation) EdgeCleared(name string) bool { +func (m *CardMutation) EdgeCleared(name string) bool { + switch name { + case card.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 *UsersMutation) ClearEdge(name string) error { - return fmt.Errorf("unknown Users unique edge %s", name) +func (m *CardMutation) ClearEdge(name string) error { + switch name { + case card.EdgeOwner: + m.ClearOwner() + return nil + } + return fmt.Errorf("unknown Card 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 *UsersMutation) ResetEdge(name string) error { - return fmt.Errorf("unknown Users edge %s", name) +func (m *CardMutation) ResetEdge(name string) error { + switch name { + case card.EdgeOwner: + m.ResetOwner() + return nil + } + return fmt.Errorf("unknown Card edge %s", name) +} + +// GroupMutation represents an operation that mutates the Group nodes in the graph. +type GroupMutation struct { + config + op Op + typ string + id *int + name *string + clearedFields map[string]struct{} + users map[int]struct{} + removedusers map[int]struct{} + clearedusers bool + done bool + oldValue func(context.Context) (*Group, error) + predicates []predicate.Group +} + +var _ ent.Mutation = (*GroupMutation)(nil) + +// groupOption allows management of the mutation configuration using functional options. +type groupOption func(*GroupMutation) + +// newGroupMutation creates new mutation for the Group entity. +func newGroupMutation(c config, op Op, opts ...groupOption) *GroupMutation { + m := &GroupMutation{ + config: c, + op: op, + typ: TypeGroup, + clearedFields: make(map[string]struct{}), + } + for _, opt := range opts { + opt(m) + } + return m +} + +// withGroupID sets the ID field of the mutation. +func withGroupID(id int) groupOption { + return func(m *GroupMutation) { + var ( + err error + once sync.Once + value *Group + ) + m.oldValue = func(ctx context.Context) (*Group, error) { + once.Do(func() { + if m.done { + err = errors.New("querying old values post mutation is not allowed") + } else { + value, err = m.Client().Group.Get(ctx, id) + } + }) + return value, err + } + m.id = &id + } +} + +// withGroup sets the old Group of the mutation. +func withGroup(node *Group) groupOption { + return func(m *GroupMutation) { + m.oldValue = func(context.Context) (*Group, 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 GroupMutation) 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 GroupMutation) 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 *GroupMutation) 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 *GroupMutation) 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().Group.Query().Where(m.predicates...).IDs(ctx) + default: + return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op) + } +} + +// SetName sets the "name" field. +func (m *GroupMutation) SetName(s string) { + m.name = &s +} + +// Name returns the value of the "name" field in the mutation. +func (m *GroupMutation) Name() (r string, exists bool) { + v := m.name + if v == nil { + return + } + return *v, true +} + +// OldName returns the old "name" field's value of the Group entity. +// If the Group 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 *GroupMutation) OldName(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldName is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldName requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldName: %w", err) + } + return oldValue.Name, nil +} + +// ResetName resets all changes to the "name" field. +func (m *GroupMutation) ResetName() { + m.name = nil +} + +// AddUserIDs adds the "users" edge to the User entity by ids. +func (m *GroupMutation) AddUserIDs(ids ...int) { + if m.users == nil { + m.users = make(map[int]struct{}) + } + for i := range ids { + m.users[ids[i]] = struct{}{} + } +} + +// ClearUsers clears the "users" edge to the User entity. +func (m *GroupMutation) ClearUsers() { + m.clearedusers = true +} + +// UsersCleared reports if the "users" edge to the User entity was cleared. +func (m *GroupMutation) UsersCleared() bool { + return m.clearedusers +} + +// RemoveUserIDs removes the "users" edge to the User entity by IDs. +func (m *GroupMutation) RemoveUserIDs(ids ...int) { + if m.removedusers == nil { + m.removedusers = make(map[int]struct{}) + } + for i := range ids { + delete(m.users, ids[i]) + m.removedusers[ids[i]] = struct{}{} + } +} + +// RemovedUsers returns the removed IDs of the "users" edge to the User entity. +func (m *GroupMutation) RemovedUsersIDs() (ids []int) { + for id := range m.removedusers { + ids = append(ids, id) + } + return +} + +// UsersIDs returns the "users" edge IDs in the mutation. +func (m *GroupMutation) UsersIDs() (ids []int) { + for id := range m.users { + ids = append(ids, id) + } + return +} + +// ResetUsers resets all changes to the "users" edge. +func (m *GroupMutation) ResetUsers() { + m.users = nil + m.clearedusers = false + m.removedusers = nil +} + +// Where appends a list predicates to the GroupMutation builder. +func (m *GroupMutation) Where(ps ...predicate.Group) { + m.predicates = append(m.predicates, ps...) +} + +// WhereP appends storage-level predicates to the GroupMutation builder. Using this method, +// users can use type-assertion to append predicates that do not depend on any generated package. +func (m *GroupMutation) WhereP(ps ...func(*sql.Selector)) { + p := make([]predicate.Group, len(ps)) + for i := range ps { + p[i] = ps[i] + } + m.Where(p...) +} + +// Op returns the operation name. +func (m *GroupMutation) Op() Op { + return m.op +} + +// SetOp allows setting the mutation operation. +func (m *GroupMutation) SetOp(op Op) { + m.op = op +} + +// Type returns the node type of this mutation (Group). +func (m *GroupMutation) 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 *GroupMutation) Fields() []string { + fields := make([]string, 0, 1) + if m.name != nil { + fields = append(fields, group.FieldName) + } + return fields +} + +// Field returns the value of a field with the given name. The second boolean +// return value indicates that this field was not set, or was not defined in the +// schema. +func (m *GroupMutation) Field(name string) (ent.Value, bool) { + switch name { + case group.FieldName: + return m.Name() + } + return nil, false +} + +// OldField returns the old value of the field from the database. An error is +// returned if the mutation operation is not UpdateOne, or the query to the +// database failed. +func (m *GroupMutation) OldField(ctx context.Context, name string) (ent.Value, error) { + switch name { + case group.FieldName: + return m.OldName(ctx) + } + return nil, fmt.Errorf("unknown Group 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 *GroupMutation) SetField(name string, value ent.Value) error { + switch name { + case group.FieldName: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetName(v) + return nil + } + return fmt.Errorf("unknown Group field %s", name) +} + +// AddedFields returns all numeric fields that were incremented/decremented during +// this mutation. +func (m *GroupMutation) AddedFields() []string { + return nil +} + +// AddedField returns the numeric value that was incremented/decremented on a field +// with the given name. The second boolean return value indicates that this field +// was not set, or was not defined in the schema. +func (m *GroupMutation) AddedField(name string) (ent.Value, bool) { + return nil, false +} + +// AddField adds the value to the field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *GroupMutation) AddField(name string, value ent.Value) error { + switch name { + } + return fmt.Errorf("unknown Group numeric field %s", name) +} + +// ClearedFields returns all nullable fields that were cleared during this +// mutation. +func (m *GroupMutation) ClearedFields() []string { + return nil +} + +// FieldCleared returns a boolean indicating if a field with the given name was +// cleared in this mutation. +func (m *GroupMutation) 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 *GroupMutation) ClearField(name string) error { + return fmt.Errorf("unknown Group 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 *GroupMutation) ResetField(name string) error { + switch name { + case group.FieldName: + m.ResetName() + return nil + } + return fmt.Errorf("unknown Group field %s", name) +} + +// AddedEdges returns all edge names that were set/added in this mutation. +func (m *GroupMutation) AddedEdges() []string { + edges := make([]string, 0, 1) + if m.users != nil { + edges = append(edges, group.EdgeUsers) + } + return edges +} + +// AddedIDs returns all IDs (to other nodes) that were added for the given edge +// name in this mutation. +func (m *GroupMutation) AddedIDs(name string) []ent.Value { + switch name { + case group.EdgeUsers: + ids := make([]ent.Value, 0, len(m.users)) + for id := range m.users { + ids = append(ids, id) + } + return ids + } + return nil +} + +// RemovedEdges returns all edge names that were removed in this mutation. +func (m *GroupMutation) RemovedEdges() []string { + edges := make([]string, 0, 1) + if m.removedusers != nil { + edges = append(edges, group.EdgeUsers) + } + return edges +} + +// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with +// the given name in this mutation. +func (m *GroupMutation) RemovedIDs(name string) []ent.Value { + switch name { + case group.EdgeUsers: + ids := make([]ent.Value, 0, len(m.removedusers)) + for id := range m.removedusers { + ids = append(ids, id) + } + return ids + } + return nil +} + +// ClearedEdges returns all edge names that were cleared in this mutation. +func (m *GroupMutation) ClearedEdges() []string { + edges := make([]string, 0, 1) + if m.clearedusers { + edges = append(edges, group.EdgeUsers) + } + return edges +} + +// EdgeCleared returns a boolean which indicates if the edge with the given name +// was cleared in this mutation. +func (m *GroupMutation) EdgeCleared(name string) bool { + switch name { + case group.EdgeUsers: + return m.clearedusers + } + return false +} + +// ClearEdge clears the value of the edge with the given name. It returns an error +// if that edge is not defined in the schema. +func (m *GroupMutation) ClearEdge(name string) error { + switch name { + } + return fmt.Errorf("unknown Group 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 *GroupMutation) ResetEdge(name string) error { + switch name { + case group.EdgeUsers: + m.ResetUsers() + return nil + } + return fmt.Errorf("unknown Group edge %s", name) +} + +// UserMutation represents an operation that mutates the User nodes in the graph. +type UserMutation struct { + config + op Op + typ string + id *int + username *string + created_at *time.Time + updated_at *time.Time + next *string + clearedFields map[string]struct{} + card map[int]struct{} + removedcard map[int]struct{} + clearedcard bool + done bool + oldValue func(context.Context) (*User, error) + predicates []predicate.User +} + +var _ ent.Mutation = (*UserMutation)(nil) + +// userOption allows management of the mutation configuration using functional options. +type userOption func(*UserMutation) + +// newUserMutation creates new mutation for the User entity. +func newUserMutation(c config, op Op, opts ...userOption) *UserMutation { + m := &UserMutation{ + config: c, + op: op, + typ: TypeUser, + clearedFields: make(map[string]struct{}), + } + for _, opt := range opts { + opt(m) + } + return m +} + +// withUserID sets the ID field of the mutation. +func withUserID(id int) userOption { + return func(m *UserMutation) { + var ( + err error + once sync.Once + value *User + ) + m.oldValue = func(ctx context.Context) (*User, error) { + once.Do(func() { + if m.done { + err = errors.New("querying old values post mutation is not allowed") + } else { + value, err = m.Client().User.Get(ctx, id) + } + }) + return value, err + } + m.id = &id + } +} + +// withUser sets the old User of the mutation. +func withUser(node *User) userOption { + return func(m *UserMutation) { + m.oldValue = func(context.Context) (*User, error) { + return node, nil + } + m.id = &node.ID + } +} + +// Client returns a new `ent.Client` from the mutation. If the mutation was +// executed in a transaction (ent.Tx), a transactional client is returned. +func (m UserMutation) Client() *Client { + client := &Client{config: m.config} + client.init() + return client +} + +// Tx returns an `ent.Tx` for mutations that were executed in transactions; +// it returns an error otherwise. +func (m UserMutation) Tx() (*Tx, error) { + if _, ok := m.driver.(*txDriver); !ok { + return nil, errors.New("ent: mutation is not running in a transaction") + } + tx := &Tx{config: m.config} + tx.init() + return tx, nil +} + +// ID returns the ID value in the mutation. Note that the ID is only available +// if it was provided to the builder or after it was returned from the database. +func (m *UserMutation) ID() (id int, exists bool) { + if m.id == nil { + return + } + return *m.id, true +} + +// IDs queries the database and returns the entity ids that match the mutation's predicate. +// That means, if the mutation is applied within a transaction with an isolation level such +// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated +// or updated by the mutation. +func (m *UserMutation) IDs(ctx context.Context) ([]int, error) { + switch { + case m.op.Is(OpUpdateOne | OpDeleteOne): + id, exists := m.ID() + if exists { + return []int{id}, nil + } + fallthrough + case m.op.Is(OpUpdate | OpDelete): + return m.Client().User.Query().Where(m.predicates...).IDs(ctx) + default: + return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op) + } +} + +// SetUsername sets the "username" field. +func (m *UserMutation) SetUsername(s string) { + m.username = &s +} + +// Username returns the value of the "username" field in the mutation. +func (m *UserMutation) Username() (r string, exists bool) { + v := m.username + if v == nil { + return + } + return *v, true +} + +// OldUsername returns the old "username" field's value of the User entity. +// If the User object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *UserMutation) OldUsername(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUsername is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUsername requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUsername: %w", err) + } + return oldValue.Username, nil +} + +// ResetUsername resets all changes to the "username" field. +func (m *UserMutation) ResetUsername() { + m.username = nil +} + +// SetCreatedAt sets the "created_at" field. +func (m *UserMutation) SetCreatedAt(t time.Time) { + m.created_at = &t +} + +// CreatedAt returns the value of the "created_at" field in the mutation. +func (m *UserMutation) CreatedAt() (r time.Time, exists bool) { + v := m.created_at + if v == nil { + return + } + return *v, true +} + +// OldCreatedAt returns the old "created_at" field's value of the User entity. +// If the User object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *UserMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCreatedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err) + } + return oldValue.CreatedAt, nil +} + +// ClearCreatedAt clears the value of the "created_at" field. +func (m *UserMutation) ClearCreatedAt() { + m.created_at = nil + m.clearedFields[user.FieldCreatedAt] = struct{}{} +} + +// CreatedAtCleared returns if the "created_at" field was cleared in this mutation. +func (m *UserMutation) CreatedAtCleared() bool { + _, ok := m.clearedFields[user.FieldCreatedAt] + return ok +} + +// ResetCreatedAt resets all changes to the "created_at" field. +func (m *UserMutation) ResetCreatedAt() { + m.created_at = nil + delete(m.clearedFields, user.FieldCreatedAt) +} + +// SetUpdatedAt sets the "updated_at" field. +func (m *UserMutation) SetUpdatedAt(t time.Time) { + m.updated_at = &t +} + +// UpdatedAt returns the value of the "updated_at" field in the mutation. +func (m *UserMutation) UpdatedAt() (r time.Time, exists bool) { + v := m.updated_at + if v == nil { + return + } + return *v, true +} + +// OldUpdatedAt returns the old "updated_at" field's value of the User entity. +// If the User object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *UserMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUpdatedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err) + } + return oldValue.UpdatedAt, nil +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (m *UserMutation) ClearUpdatedAt() { + m.updated_at = nil + m.clearedFields[user.FieldUpdatedAt] = struct{}{} +} + +// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation. +func (m *UserMutation) UpdatedAtCleared() bool { + _, ok := m.clearedFields[user.FieldUpdatedAt] + return ok +} + +// ResetUpdatedAt resets all changes to the "updated_at" field. +func (m *UserMutation) ResetUpdatedAt() { + m.updated_at = nil + delete(m.clearedFields, user.FieldUpdatedAt) +} + +// SetNext sets the "next" field. +func (m *UserMutation) SetNext(s string) { + m.next = &s +} + +// Next returns the value of the "next" field in the mutation. +func (m *UserMutation) Next() (r string, exists bool) { + v := m.next + if v == nil { + return + } + return *v, true +} + +// OldNext returns the old "next" field's value of the User entity. +// If the User object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *UserMutation) OldNext(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldNext is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldNext requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldNext: %w", err) + } + return oldValue.Next, nil +} + +// ClearNext clears the value of the "next" field. +func (m *UserMutation) ClearNext() { + m.next = nil + m.clearedFields[user.FieldNext] = struct{}{} +} + +// NextCleared returns if the "next" field was cleared in this mutation. +func (m *UserMutation) NextCleared() bool { + _, ok := m.clearedFields[user.FieldNext] + return ok +} + +// ResetNext resets all changes to the "next" field. +func (m *UserMutation) ResetNext() { + m.next = nil + delete(m.clearedFields, user.FieldNext) +} + +// AddCardIDs adds the "card" edge to the Card entity by ids. +func (m *UserMutation) AddCardIDs(ids ...int) { + if m.card == nil { + m.card = make(map[int]struct{}) + } + for i := range ids { + m.card[ids[i]] = struct{}{} + } +} + +// ClearCard clears the "card" edge to the Card entity. +func (m *UserMutation) ClearCard() { + m.clearedcard = true +} + +// CardCleared reports if the "card" edge to the Card entity was cleared. +func (m *UserMutation) CardCleared() bool { + return m.clearedcard +} + +// RemoveCardIDs removes the "card" edge to the Card entity by IDs. +func (m *UserMutation) RemoveCardIDs(ids ...int) { + if m.removedcard == nil { + m.removedcard = make(map[int]struct{}) + } + for i := range ids { + delete(m.card, ids[i]) + m.removedcard[ids[i]] = struct{}{} + } +} + +// RemovedCard returns the removed IDs of the "card" edge to the Card entity. +func (m *UserMutation) RemovedCardIDs() (ids []int) { + for id := range m.removedcard { + ids = append(ids, id) + } + return +} + +// CardIDs returns the "card" edge IDs in the mutation. +func (m *UserMutation) CardIDs() (ids []int) { + for id := range m.card { + ids = append(ids, id) + } + return +} + +// ResetCard resets all changes to the "card" edge. +func (m *UserMutation) ResetCard() { + m.card = nil + m.clearedcard = false + m.removedcard = nil +} + +// Where appends a list predicates to the UserMutation builder. +func (m *UserMutation) Where(ps ...predicate.User) { + m.predicates = append(m.predicates, ps...) +} + +// WhereP appends storage-level predicates to the UserMutation builder. Using this method, +// users can use type-assertion to append predicates that do not depend on any generated package. +func (m *UserMutation) WhereP(ps ...func(*sql.Selector)) { + p := make([]predicate.User, len(ps)) + for i := range ps { + p[i] = ps[i] + } + m.Where(p...) +} + +// Op returns the operation name. +func (m *UserMutation) Op() Op { + return m.op +} + +// SetOp allows setting the mutation operation. +func (m *UserMutation) SetOp(op Op) { + m.op = op +} + +// Type returns the node type of this mutation (User). +func (m *UserMutation) Type() string { + return m.typ +} + +// Fields returns all fields that were changed during this mutation. Note that in +// order to get all numeric fields that were incremented/decremented, call +// AddedFields(). +func (m *UserMutation) Fields() []string { + fields := make([]string, 0, 4) + if m.username != nil { + fields = append(fields, user.FieldUsername) + } + if m.created_at != nil { + fields = append(fields, user.FieldCreatedAt) + } + if m.updated_at != nil { + fields = append(fields, user.FieldUpdatedAt) + } + if m.next != nil { + fields = append(fields, user.FieldNext) + } + return fields +} + +// Field returns the value of a field with the given name. The second boolean +// return value indicates that this field was not set, or was not defined in the +// schema. +func (m *UserMutation) Field(name string) (ent.Value, bool) { + switch name { + case user.FieldUsername: + return m.Username() + case user.FieldCreatedAt: + return m.CreatedAt() + case user.FieldUpdatedAt: + return m.UpdatedAt() + case user.FieldNext: + return m.Next() + } + return nil, false +} + +// OldField returns the old value of the field from the database. An error is +// returned if the mutation operation is not UpdateOne, or the query to the +// database failed. +func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error) { + switch name { + case user.FieldUsername: + return m.OldUsername(ctx) + case user.FieldCreatedAt: + return m.OldCreatedAt(ctx) + case user.FieldUpdatedAt: + return m.OldUpdatedAt(ctx) + case user.FieldNext: + return m.OldNext(ctx) + } + return nil, fmt.Errorf("unknown User field %s", name) +} + +// SetField sets the value of a field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *UserMutation) SetField(name string, value ent.Value) error { + switch name { + case user.FieldUsername: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUsername(v) + return nil + case user.FieldCreatedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCreatedAt(v) + return nil + case user.FieldUpdatedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUpdatedAt(v) + return nil + case user.FieldNext: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetNext(v) + return nil + } + return fmt.Errorf("unknown User field %s", name) +} + +// AddedFields returns all numeric fields that were incremented/decremented during +// this mutation. +func (m *UserMutation) AddedFields() []string { + return nil +} + +// AddedField returns the numeric value that was incremented/decremented on a field +// with the given name. The second boolean return value indicates that this field +// was not set, or was not defined in the schema. +func (m *UserMutation) AddedField(name string) (ent.Value, bool) { + return nil, false +} + +// AddField adds the value to the field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *UserMutation) AddField(name string, value ent.Value) error { + switch name { + } + return fmt.Errorf("unknown User numeric field %s", name) +} + +// ClearedFields returns all nullable fields that were cleared during this +// mutation. +func (m *UserMutation) ClearedFields() []string { + var fields []string + if m.FieldCleared(user.FieldCreatedAt) { + fields = append(fields, user.FieldCreatedAt) + } + if m.FieldCleared(user.FieldUpdatedAt) { + fields = append(fields, user.FieldUpdatedAt) + } + if m.FieldCleared(user.FieldNext) { + fields = append(fields, user.FieldNext) + } + return fields +} + +// FieldCleared returns a boolean indicating if a field with the given name was +// cleared in this mutation. +func (m *UserMutation) FieldCleared(name string) bool { + _, ok := m.clearedFields[name] + return ok +} + +// ClearField clears the value of the field with the given name. It returns an +// error if the field is not defined in the schema. +func (m *UserMutation) ClearField(name string) error { + switch name { + case user.FieldCreatedAt: + m.ClearCreatedAt() + return nil + case user.FieldUpdatedAt: + m.ClearUpdatedAt() + return nil + case user.FieldNext: + m.ClearNext() + return nil + } + return fmt.Errorf("unknown User nullable field %s", name) +} + +// ResetField resets all changes in the mutation for the field with the given name. +// It returns an error if the field is not defined in the schema. +func (m *UserMutation) ResetField(name string) error { + switch name { + case user.FieldUsername: + m.ResetUsername() + return nil + case user.FieldCreatedAt: + m.ResetCreatedAt() + return nil + case user.FieldUpdatedAt: + m.ResetUpdatedAt() + return nil + case user.FieldNext: + m.ResetNext() + return nil + } + return fmt.Errorf("unknown User field %s", name) +} + +// AddedEdges returns all edge names that were set/added in this mutation. +func (m *UserMutation) AddedEdges() []string { + edges := make([]string, 0, 1) + if m.card != nil { + edges = append(edges, user.EdgeCard) + } + return edges +} + +// AddedIDs returns all IDs (to other nodes) that were added for the given edge +// name in this mutation. +func (m *UserMutation) AddedIDs(name string) []ent.Value { + switch name { + case user.EdgeCard: + ids := make([]ent.Value, 0, len(m.card)) + for id := range m.card { + 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, 1) + if m.removedcard != nil { + edges = append(edges, user.EdgeCard) + } + return edges +} + +// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with +// the given name in this mutation. +func (m *UserMutation) RemovedIDs(name string) []ent.Value { + switch name { + case user.EdgeCard: + ids := make([]ent.Value, 0, len(m.removedcard)) + for id := range m.removedcard { + 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, 1) + if m.clearedcard { + edges = append(edges, user.EdgeCard) + } + return edges +} + +// EdgeCleared returns a boolean which indicates if the edge with the given name +// was cleared in this mutation. +func (m *UserMutation) EdgeCleared(name string) bool { + switch name { + case user.EdgeCard: + return m.clearedcard + } + return false +} + +// ClearEdge clears the value of the edge with the given name. It returns an error +// if that edge is not defined in the schema. +func (m *UserMutation) ClearEdge(name string) error { + switch name { + } + return fmt.Errorf("unknown User unique edge %s", name) +} + +// ResetEdge resets all changes to the edge with the given name in this mutation. +// It returns an error if the edge is not defined in the schema. +func (m *UserMutation) ResetEdge(name string) error { + switch name { + case user.EdgeCard: + m.ResetCard() + return nil + } + return fmt.Errorf("unknown User edge %s", name) } diff --git a/ent/ogent/oas_cfg_gen.go b/ent/ogent/oas_cfg_gen.go index f48a967..db14e1c 100644 --- a/ent/ogent/oas_cfg_gen.go +++ b/ent/ogent/oas_cfg_gen.go @@ -3,132 +3,195 @@ package ogent import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/metric" + "go.opentelemetry.io/otel/metric/instrument" "go.opentelemetry.io/otel/trace" + + ht "github.com/ogen-go/ogen/http" + "github.com/ogen-go/ogen/middleware" + "github.com/ogen-go/ogen/ogenerrors" + "github.com/ogen-go/ogen/otelogen" ) -// No-op definition for keeping imports. var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset + // Allocate option closure once. + clientSpanKind = trace.WithSpanKind(trace.SpanKindClient) + // Allocate option closure once. + serverSpanKind = trace.WithSpanKind(trace.SpanKindServer) ) -// bufPool is pool of bytes.Buffer for encoding and decoding. -var bufPool = &sync.Pool{ - New: func() interface{} { - return new(bytes.Buffer) - }, -} +type ( + optionFunc[C any] func(*C) + otelOptionFunc func(*otelConfig) +) -// getBuf returns buffer from pool. -func getBuf() *bytes.Buffer { - return bufPool.Get().(*bytes.Buffer) -} - -// putBuf puts buffer to pool. -func putBuf(b *bytes.Buffer) { - b.Reset() - bufPool.Put(b) -} - -type config struct { +type otelConfig struct { TracerProvider trace.TracerProvider Tracer trace.Tracer MeterProvider metric.MeterProvider Meter metric.Meter - Client ht.Client - NotFound http.HandlerFunc } -func newConfig(opts ...Option) config { - cfg := config{ - TracerProvider: otel.GetTracerProvider(), - MeterProvider: metric.NewNoopMeterProvider(), - Client: http.DefaultClient, - NotFound: http.NotFound, +func (cfg *otelConfig) initOTEL() { + if cfg.TracerProvider == nil { + cfg.TracerProvider = otel.GetTracerProvider() } - for _, opt := range opts { - opt.apply(&cfg) + if cfg.MeterProvider == nil { + cfg.MeterProvider = metric.NewNoopMeterProvider() } cfg.Tracer = cfg.TracerProvider.Tracer(otelogen.Name, trace.WithInstrumentationVersion(otelogen.SemVersion()), ) cfg.Meter = cfg.MeterProvider.Meter(otelogen.Name) +} + +// ErrorHandler is error handler. +type ErrorHandler = ogenerrors.ErrorHandler + +type serverConfig struct { + otelConfig + NotFound http.HandlerFunc + MethodNotAllowed func(w http.ResponseWriter, r *http.Request, allowed string) + ErrorHandler ErrorHandler + Prefix string + Middleware Middleware + MaxMultipartMemory int64 +} + +// ServerOption is server config option. +type ServerOption interface { + applyServer(*serverConfig) +} + +var _ = []ServerOption{ + (optionFunc[serverConfig])(nil), + (otelOptionFunc)(nil), +} + +func (o optionFunc[C]) applyServer(c *C) { + o(c) +} + +func (o otelOptionFunc) applyServer(c *serverConfig) { + o(&c.otelConfig) +} + +func newServerConfig(opts ...ServerOption) serverConfig { + cfg := serverConfig{ + NotFound: http.NotFound, + MethodNotAllowed: func(w http.ResponseWriter, r *http.Request, allowed string) { + w.Header().Set("Allow", allowed) + w.WriteHeader(http.StatusMethodNotAllowed) + }, + ErrorHandler: ogenerrors.DefaultErrorHandler, + Middleware: nil, + MaxMultipartMemory: 32 << 20, // 32 MB + } + for _, opt := range opts { + opt.applyServer(&cfg) + } + cfg.initOTEL() return cfg } -type Option interface { - apply(*config) +type baseServer struct { + cfg serverConfig + requests instrument.Int64Counter + errors instrument.Int64Counter + duration instrument.Int64Histogram } -type optionFunc func(*config) +func (s baseServer) notFound(w http.ResponseWriter, r *http.Request) { + s.cfg.NotFound(w, r) +} -func (o optionFunc) apply(c *config) { +func (s baseServer) notAllowed(w http.ResponseWriter, r *http.Request, allowed string) { + s.cfg.MethodNotAllowed(w, r, allowed) +} + +func (cfg serverConfig) baseServer() (s baseServer, err error) { + s = baseServer{cfg: cfg} + if s.requests, err = s.cfg.Meter.Int64Counter(otelogen.ServerRequestCount); err != nil { + return s, err + } + if s.errors, err = s.cfg.Meter.Int64Counter(otelogen.ServerErrorsCount); err != nil { + return s, err + } + if s.duration, err = s.cfg.Meter.Int64Histogram(otelogen.ServerDuration); err != nil { + return s, err + } + return s, nil +} + +type clientConfig struct { + otelConfig + Client ht.Client +} + +// ClientOption is client config option. +type ClientOption interface { + applyClient(*clientConfig) +} + +var _ = []ClientOption{ + (optionFunc[clientConfig])(nil), + (otelOptionFunc)(nil), +} + +func (o optionFunc[C]) applyClient(c *C) { o(c) } +func (o otelOptionFunc) applyClient(c *clientConfig) { + o(&c.otelConfig) +} + +func newClientConfig(opts ...ClientOption) clientConfig { + cfg := clientConfig{ + Client: http.DefaultClient, + } + for _, opt := range opts { + opt.applyClient(&cfg) + } + cfg.initOTEL() + return cfg +} + +type baseClient struct { + cfg clientConfig + requests instrument.Int64Counter + errors instrument.Int64Counter + duration instrument.Int64Histogram +} + +func (cfg clientConfig) baseClient() (c baseClient, err error) { + c = baseClient{cfg: cfg} + if c.requests, err = c.cfg.Meter.Int64Counter(otelogen.ClientRequestCount); err != nil { + return c, err + } + if c.errors, err = c.cfg.Meter.Int64Counter(otelogen.ClientErrorsCount); err != nil { + return c, err + } + if c.duration, err = c.cfg.Meter.Int64Histogram(otelogen.ClientDuration); err != nil { + return c, err + } + return c, nil +} + +// Option is config option. +type Option interface { + ServerOption + ClientOption +} + // WithTracerProvider specifies a tracer provider to use for creating a tracer. // // If none is specified, the global provider is used. func WithTracerProvider(provider trace.TracerProvider) Option { - return optionFunc(func(cfg *config) { + return otelOptionFunc(func(cfg *otelConfig) { if provider != nil { cfg.TracerProvider = provider } @@ -139,7 +202,7 @@ func WithTracerProvider(provider trace.TracerProvider) Option { // // If none is specified, the metric.NewNoopMeterProvider is used. func WithMeterProvider(provider metric.MeterProvider) Option { - return optionFunc(func(cfg *config) { + return otelOptionFunc(func(cfg *otelConfig) { if provider != nil { cfg.MeterProvider = provider } @@ -147,19 +210,68 @@ func WithMeterProvider(provider metric.MeterProvider) Option { } // WithClient specifies http client to use. -func WithClient(client ht.Client) Option { - return optionFunc(func(cfg *config) { +func WithClient(client ht.Client) ClientOption { + return optionFunc[clientConfig](func(cfg *clientConfig) { if client != nil { cfg.Client = client } }) } -// WithNotFound specifies http handler to use. -func WithNotFound(notFound http.HandlerFunc) Option { - return optionFunc(func(cfg *config) { +// WithNotFound specifies Not Found handler to use. +func WithNotFound(notFound http.HandlerFunc) ServerOption { + return optionFunc[serverConfig](func(cfg *serverConfig) { if notFound != nil { cfg.NotFound = notFound } }) } + +// WithMethodNotAllowed specifies Method Not Allowed handler to use. +func WithMethodNotAllowed(methodNotAllowed func(w http.ResponseWriter, r *http.Request, allowed string)) ServerOption { + return optionFunc[serverConfig](func(cfg *serverConfig) { + if methodNotAllowed != nil { + cfg.MethodNotAllowed = methodNotAllowed + } + }) +} + +// WithErrorHandler specifies error handler to use. +func WithErrorHandler(h ErrorHandler) ServerOption { + return optionFunc[serverConfig](func(cfg *serverConfig) { + if h != nil { + cfg.ErrorHandler = h + } + }) +} + +// WithPathPrefix specifies server path prefix. +func WithPathPrefix(prefix string) ServerOption { + return optionFunc[serverConfig](func(cfg *serverConfig) { + cfg.Prefix = prefix + }) +} + +// WithMiddleware specifies middlewares to use. +func WithMiddleware(m ...Middleware) ServerOption { + return optionFunc[serverConfig](func(cfg *serverConfig) { + switch len(m) { + case 0: + cfg.Middleware = nil + case 1: + cfg.Middleware = m[0] + default: + cfg.Middleware = middleware.ChainMiddlewares(m...) + } + }) +} + +// WithMaxMultipartMemory specifies limit of memory for storing file parts. +// File parts which can't be stored in memory will be stored on disk in temporary files. +func WithMaxMultipartMemory(max int64) ServerOption { + return optionFunc[serverConfig](func(cfg *serverConfig) { + if max > 0 { + cfg.MaxMultipartMemory = max + } + }) +} diff --git a/ent/ogent/oas_client_gen.go b/ent/ogent/oas_client_gen.go index 5380c2a..a601c7b 100644 --- a/ent/ogent/oas_client_gen.go +++ b/ent/ogent/oas_client_gen.go @@ -3,164 +3,126 @@ package ogent import ( - "bytes" "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" "time" "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" "go.opentelemetry.io/otel/trace" -) -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset + "github.com/ogen-go/ogen/conv" + ht "github.com/ogen-go/ogen/http" + "github.com/ogen-go/ogen/otelogen" + "github.com/ogen-go/ogen/uri" ) // Client implements OAS client. type Client struct { serverURL *url.URL - cfg config - requests metric.Int64Counter - errors metric.Int64Counter - duration metric.Int64Histogram + baseClient } +var _ Handler = struct { + *Client +}{} + // NewClient initializes new Client defined by OAS. -func NewClient(serverURL string, opts ...Option) (*Client, error) { +func NewClient(serverURL string, opts ...ClientOption) (*Client, error) { u, err := url.Parse(serverURL) if err != nil { return nil, err } - c := &Client{ - cfg: newConfig(opts...), - serverURL: u, - } - if c.requests, err = c.cfg.Meter.NewInt64Counter(otelogen.ClientRequestCount); err != nil { + c, err := newClientConfig(opts...).baseClient() + if err != nil { return nil, err } - if c.errors, err = c.cfg.Meter.NewInt64Counter(otelogen.ClientErrorsCount); err != nil { - return nil, err - } - if c.duration, err = c.cfg.Meter.NewInt64Histogram(otelogen.ClientDuration); err != nil { - return nil, err - } - return c, nil + return &Client{ + serverURL: u, + baseClient: c, + }, nil } -// CreateUsers invokes createUsers operation. -// -// Creates a new Users and persists it to storage. -// -// POST /users -func (c *Client) CreateUsers(ctx context.Context, request CreateUsersReq) (res CreateUsersRes, err error) { - if err := func() error { - if err := request.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") +type serverURLKey struct{} + +// WithServerURL sets context key to override server URL. +func WithServerURL(ctx context.Context, u *url.URL) context.Context { + return context.WithValue(ctx, serverURLKey{}, u) +} + +func (c *Client) requestURL(ctx context.Context) *url.URL { + u, ok := ctx.Value(serverURLKey{}).(*url.URL) + if !ok { + return c.serverURL } - startTime := time.Now() + return u +} + +// CreateCard invokes createCard operation. +// +// Creates a new Card and persists it to storage. +// +// POST /cards +func (c *Client) CreateCard(ctx context.Context, request *CreateCardReq) (CreateCardRes, error) { + res, err := c.sendCreateCard(ctx, request) + _ = res + return res, err +} + +func (c *Client) sendCreateCard(ctx context.Context, request *CreateCardReq) (res CreateCardRes, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("createUsers"), + otelogen.OperationID("createCard"), } - ctx, span := c.cfg.Tracer.Start(ctx, "CreateUsers", + + // 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, "CreateCard", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), + 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...) - } else { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } span.End() }() - c.requests.Add(ctx, 1, otelAttrs...) - var ( - contentType string - reqBody io.Reader - ) - contentType = "application/json" - buf, err := encodeCreateUsersRequestJSON(request, span) + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/cards" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { - return res, err + return res, errors.Wrap(err, "create request") + } + if err := encodeCreateCardRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") } - defer jx.PutEncoder(buf) - reqBody = bytes.NewReader(buf.Bytes()) - - u := uri.Clone(c.serverURL) - u.Path += "/users" - - r := ht.NewRequest(ctx, "POST", u, reqBody) - defer ht.PutRequest(r) - - r.Header.Set("Content-Type", contentType) + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { return res, errors.Wrap(err, "do request") } defer resp.Body.Close() - result, err := decodeCreateUsersResponse(resp, span) + stage = "DecodeResponse" + result, err := decodeCreateCardResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -168,32 +130,356 @@ func (c *Client) CreateUsers(ctx context.Context, request CreateUsersReq) (res C return result, nil } -// DeleteUsers invokes deleteUsers operation. +// CreateGroup invokes createGroup operation. // -// Deletes the Users with the requested ID. +// Creates a new Group and persists it to storage. // -// DELETE /users/{id} -func (c *Client) DeleteUsers(ctx context.Context, params DeleteUsersParams) (res DeleteUsersRes, err error) { - startTime := time.Now() +// POST /groups +func (c *Client) CreateGroup(ctx context.Context, request *CreateGroupReq) (CreateGroupRes, error) { + res, err := c.sendCreateGroup(ctx, request) + _ = res + return res, err +} + +func (c *Client) sendCreateGroup(ctx context.Context, request *CreateGroupReq) (res CreateGroupRes, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("deleteUsers"), + otelogen.OperationID("createGroup"), } - ctx, span := c.cfg.Tracer.Start(ctx, "DeleteUsers", + + // 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, "CreateGroup", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), + 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...) - } else { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } span.End() }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/groups" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeCreateGroupRequest(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 := decodeCreateGroupResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// CreateUser invokes createUser operation. +// +// Creates a new User and persists it to storage. +// +// POST /users +func (c *Client) CreateUser(ctx context.Context, request *CreateUserReq) (CreateUserRes, error) { + res, err := c.sendCreateUser(ctx, request) + _ = res + return res, err +} + +func (c *Client) sendCreateUser(ctx context.Context, request *CreateUserReq) (res CreateUserRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("createUser"), + } + + // 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...) - u := uri.Clone(c.serverURL) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "CreateUser", + 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" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeCreateUserRequest(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 := decodeCreateUserResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// DeleteCard invokes deleteCard operation. +// +// Deletes the Card with the requested ID. +// +// DELETE /cards/{id} +func (c *Client) DeleteCard(ctx context.Context, params DeleteCardParams) (DeleteCardRes, error) { + res, err := c.sendDeleteCard(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendDeleteCard(ctx context.Context, params DeleteCardParams) (res DeleteCardRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deleteCard"), + } + + // 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, "DeleteCard", + 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 += "/cards/" + { + // 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 := decodeDeleteCardResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// DeleteGroup invokes deleteGroup operation. +// +// Deletes the Group with the requested ID. +// +// DELETE /groups/{id} +func (c *Client) DeleteGroup(ctx context.Context, params DeleteGroupParams) (DeleteGroupRes, error) { + res, err := c.sendDeleteGroup(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendDeleteGroup(ctx context.Context, params DeleteGroupParams) (res DeleteGroupRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deleteGroup"), + } + + // 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, "DeleteGroup", + 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 += "/groups/" + { + // 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 := decodeDeleteGroupResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// DeleteUser invokes deleteUser operation. +// +// Deletes the User with the requested ID. +// +// DELETE /users/{id} +func (c *Client) DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error) { + res, err := c.sendDeleteUser(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendDeleteUser(ctx context.Context, params DeleteUserParams) (res DeleteUserRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deleteUser"), + } + + // 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, "DeleteUser", + 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. @@ -210,16 +496,21 @@ func (c *Client) DeleteUsers(ctx context.Context, params DeleteUsersParams) (res u.Path += e.Result() } - r := ht.NewRequest(ctx, "DELETE", u, nil) - defer ht.PutRequest(r) + 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() - result, err := decodeDeleteUsersResponse(resp, span) + stage = "DecodeResponse" + result, err := decodeDeleteUserResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -229,29 +520,49 @@ func (c *Client) DeleteUsers(ctx context.Context, params DeleteUsersParams) (res // DrawDone invokes drawDone operation. // -// PUT /users/{id}/d -func (c *Client) DrawDone(ctx context.Context, params DrawDoneParams) (res DrawDoneNoContent, err error) { - startTime := time.Now() +// Draws a card item as done. +// +// PUT /cards/{id}/d +func (c *Client) DrawDone(ctx context.Context, params DrawDoneParams) error { + res, err := c.sendDrawDone(ctx, params) + _ = res + return err +} + +func (c *Client) sendDrawDone(ctx context.Context, params DrawDoneParams) (res *DrawDoneNoContent, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("drawDone"), } + + // 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, "DrawDone", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), + 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...) - } else { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } span.End() }() - c.requests.Add(ctx, 1, otelAttrs...) - u := uri.Clone(c.serverURL) - u.Path += "/users/" + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/cards/" { // Encode "id" parameter. e := uri.NewPathEncoder(uri.PathEncoderConfig{ @@ -268,16 +579,21 @@ func (c *Client) DrawDone(ctx context.Context, params DrawDoneParams) (res DrawD } u.Path += "/d" - r := ht.NewRequest(ctx, "PUT", u, nil) - defer ht.PutRequest(r) + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "PUT", 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() - result, err := decodeDrawDoneResponse(resp, span) + stage = "DecodeResponse" + result, err := decodeDrawDoneResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -287,28 +603,48 @@ func (c *Client) DrawDone(ctx context.Context, params DrawDoneParams) (res DrawD // DrawStart invokes drawStart operation. // -// PATCH /users/{id}/start -func (c *Client) DrawStart(ctx context.Context, params DrawStartParams) (res DrawStartNoContent, err error) { - startTime := time.Now() +// Draws a card item as done. +// +// PATCH /users/{id}/card/start +func (c *Client) DrawStart(ctx context.Context, params DrawStartParams) error { + res, err := c.sendDrawStart(ctx, params) + _ = res + return err +} + +func (c *Client) sendDrawStart(ctx context.Context, params DrawStartParams) (res *DrawStartNoContent, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("drawStart"), } + + // 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, "DrawStart", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), + 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...) - } else { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } span.End() }() - c.requests.Add(ctx, 1, otelAttrs...) - u := uri.Clone(c.serverURL) + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) u.Path += "/users/" { // Encode "id" parameter. @@ -324,18 +660,23 @@ func (c *Client) DrawStart(ctx context.Context, params DrawStartParams) (res Dra } u.Path += e.Result() } - u.Path += "/start" + u.Path += "/card/start" - r := ht.NewRequest(ctx, "PATCH", u, nil) - defer ht.PutRequest(r) + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "PATCH", 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() - result, err := decodeDrawStartResponse(resp, span) + stage = "DecodeResponse" + result, err := decodeDrawStartResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -343,79 +684,105 @@ func (c *Client) DrawStart(ctx context.Context, params DrawStartParams) (res Dra return result, nil } -// ListUsers invokes listUsers operation. +// ListCard invokes listCard operation. // -// List Users. +// List Cards. // -// GET /users -func (c *Client) ListUsers(ctx context.Context, params ListUsersParams) (res ListUsersRes, err error) { - startTime := time.Now() +// GET /cards +func (c *Client) ListCard(ctx context.Context, params ListCardParams) (ListCardRes, error) { + res, err := c.sendListCard(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendListCard(ctx context.Context, params ListCardParams) (res ListCardRes, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("listUsers"), + otelogen.OperationID("listCard"), } - ctx, span := c.cfg.Tracer.Start(ctx, "ListUsers", + + // 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, "ListCard", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), + 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...) - } else { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } span.End() }() - c.requests.Add(ctx, 1, otelAttrs...) - u := uri.Clone(c.serverURL) - u.Path += "/users" - q := u.Query() + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/cards" + + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() { // Encode "page" parameter. - e := uri.NewQueryEncoder(uri.QueryEncoderConfig{ + cfg := uri.QueryParameterEncodingConfig{ + Name: "page", Style: uri.QueryStyleForm, Explode: true, - }) - if err := func() error { + } + + 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 { + }); err != nil { return res, errors.Wrap(err, "encode query") } - q["page"] = e.Result() } { // Encode "itemsPerPage" parameter. - e := uri.NewQueryEncoder(uri.QueryEncoderConfig{ + cfg := uri.QueryParameterEncodingConfig{ + Name: "itemsPerPage", Style: uri.QueryStyleForm, Explode: true, - }) - if err := func() error { + } + + 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 { + }); err != nil { return res, errors.Wrap(err, "encode query") } - q["itemsPerPage"] = e.Result() } - u.RawQuery = q.Encode() + u.RawQuery = q.Values().Encode() - r := ht.NewRequest(ctx, "GET", u, nil) - defer ht.PutRequest(r) + 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() - result, err := decodeListUsersResponse(resp, span) + stage = "DecodeResponse" + result, err := decodeListCardResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -423,32 +790,751 @@ func (c *Client) ListUsers(ctx context.Context, params ListUsersParams) (res Lis return result, nil } -// ReadUsers invokes readUsers operation. +// ListGroup invokes listGroup operation. // -// Finds the Users with the requested ID and returns it. +// List Groups. +// +// GET /groups +func (c *Client) ListGroup(ctx context.Context, params ListGroupParams) (ListGroupRes, error) { + res, err := c.sendListGroup(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendListGroup(ctx context.Context, params ListGroupParams) (res ListGroupRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listGroup"), + } + + // 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, "ListGroup", + 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 += "/groups" + + 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 := decodeListGroupResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListGroupUsers invokes listGroupUsers operation. +// +// List attached Users. +// +// GET /groups/{id}/users +func (c *Client) ListGroupUsers(ctx context.Context, params ListGroupUsersParams) (ListGroupUsersRes, error) { + res, err := c.sendListGroupUsers(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendListGroupUsers(ctx context.Context, params ListGroupUsersParams) (res ListGroupUsersRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listGroupUsers"), + } + + // 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, "ListGroupUsers", + 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 += "/groups/" + { + // 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 += "/users" + + 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 := decodeListGroupUsersResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListUser invokes listUser operation. +// +// List Users. +// +// GET /users +func (c *Client) ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error) { + res, err := c.sendListUser(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendListUser(ctx context.Context, params ListUserParams) (res ListUserRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listUser"), + } + + // 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, "ListUser", + 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" + + 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 := decodeListUserResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListUserCard invokes listUserCard operation. +// +// List attached Cards. +// +// GET /users/{id}/card +func (c *Client) ListUserCard(ctx context.Context, params ListUserCardParams) (ListUserCardRes, error) { + res, err := c.sendListUserCard(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendListUserCard(ctx context.Context, params ListUserCardParams) (res ListUserCardRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listUserCard"), + } + + // 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, "ListUserCard", + 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 += "/card" + + 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 := decodeListUserCardResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ReadCard invokes readCard operation. +// +// Finds the Card with the requested ID and returns it. +// +// GET /cards/{id} +func (c *Client) ReadCard(ctx context.Context, params ReadCardParams) (ReadCardRes, error) { + res, err := c.sendReadCard(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendReadCard(ctx context.Context, params ReadCardParams) (res ReadCardRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readCard"), + } + + // 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, "ReadCard", + 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 += "/cards/" + { + // 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 := decodeReadCardResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ReadCardOwner invokes readCardOwner operation. +// +// Find the attached User of the Card with the given ID. +// +// GET /cards/{id}/owner +func (c *Client) ReadCardOwner(ctx context.Context, params ReadCardOwnerParams) (ReadCardOwnerRes, error) { + res, err := c.sendReadCardOwner(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendReadCardOwner(ctx context.Context, params ReadCardOwnerParams) (res ReadCardOwnerRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readCardOwner"), + } + + // 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, "ReadCardOwner", + 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 += "/cards/" + { + // 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 := decodeReadCardOwnerResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ReadGroup invokes readGroup operation. +// +// Finds the Group with the requested ID and returns it. +// +// GET /groups/{id} +func (c *Client) ReadGroup(ctx context.Context, params ReadGroupParams) (ReadGroupRes, error) { + res, err := c.sendReadGroup(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendReadGroup(ctx context.Context, params ReadGroupParams) (res ReadGroupRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readGroup"), + } + + // 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, "ReadGroup", + 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 += "/groups/" + { + // 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 := decodeReadGroupResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ReadUser invokes readUser operation. +// +// Finds the User with the requested ID and returns it. // // GET /users/{id} -func (c *Client) ReadUsers(ctx context.Context, params ReadUsersParams) (res ReadUsersRes, err error) { - startTime := time.Now() +func (c *Client) ReadUser(ctx context.Context, params ReadUserParams) (ReadUserRes, error) { + res, err := c.sendReadUser(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendReadUser(ctx context.Context, params ReadUserParams) (res ReadUserRes, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("readUsers"), + otelogen.OperationID("readUser"), } - ctx, span := c.cfg.Tracer.Start(ctx, "ReadUsers", + + // 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, "ReadUser", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), + 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...) - } else { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } span.End() }() - c.requests.Add(ctx, 1, otelAttrs...) - u := uri.Clone(c.serverURL) + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) u.Path += "/users/" { // Encode "id" parameter. @@ -465,16 +1551,21 @@ func (c *Client) ReadUsers(ctx context.Context, params ReadUsersParams) (res Rea u.Path += e.Result() } - r := ht.NewRequest(ctx, "GET", u, nil) - defer ht.PutRequest(r) + 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() - result, err := decodeReadUsersResponse(resp, span) + stage = "DecodeResponse" + result, err := decodeReadUserResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -482,52 +1573,220 @@ func (c *Client) ReadUsers(ctx context.Context, params ReadUsersParams) (res Rea return result, nil } -// UpdateUsers invokes updateUsers operation. +// UpdateCard invokes updateCard operation. // -// Updates a Users and persists changes to storage. +// Updates a Card and persists changes to storage. +// +// PATCH /cards/{id} +func (c *Client) UpdateCard(ctx context.Context, request *UpdateCardReq, params UpdateCardParams) (UpdateCardRes, error) { + res, err := c.sendUpdateCard(ctx, request, params) + _ = res + return res, err +} + +func (c *Client) sendUpdateCard(ctx context.Context, request *UpdateCardReq, params UpdateCardParams) (res UpdateCardRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("updateCard"), + } + + // 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, "UpdateCard", + 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 += "/cards/" + { + // 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 := encodeUpdateCardRequest(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 := decodeUpdateCardResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// UpdateGroup invokes updateGroup operation. +// +// Updates a Group and persists changes to storage. +// +// PATCH /groups/{id} +func (c *Client) UpdateGroup(ctx context.Context, request *UpdateGroupReq, params UpdateGroupParams) (UpdateGroupRes, error) { + res, err := c.sendUpdateGroup(ctx, request, params) + _ = res + return res, err +} + +func (c *Client) sendUpdateGroup(ctx context.Context, request *UpdateGroupReq, params UpdateGroupParams) (res UpdateGroupRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("updateGroup"), + } + + // 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, "UpdateGroup", + 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 += "/groups/" + { + // 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 := encodeUpdateGroupRequest(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 := decodeUpdateGroupResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// UpdateUser invokes updateUser operation. +// +// Updates a User and persists changes to storage. // // PATCH /users/{id} -func (c *Client) UpdateUsers(ctx context.Context, request UpdateUsersReq, params UpdateUsersParams) (res UpdateUsersRes, err error) { - if err := func() error { - if err := request.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } - startTime := time.Now() +func (c *Client) UpdateUser(ctx context.Context, request *UpdateUserReq, params UpdateUserParams) (UpdateUserRes, error) { + res, err := c.sendUpdateUser(ctx, request, params) + _ = res + return res, err +} + +func (c *Client) sendUpdateUser(ctx context.Context, request *UpdateUserReq, params UpdateUserParams) (res UpdateUserRes, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("updateUsers"), + otelogen.OperationID("updateUser"), } - ctx, span := c.cfg.Tracer.Start(ctx, "UpdateUsers", + + // 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, "UpdateUser", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), + 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...) - } else { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } span.End() }() - c.requests.Add(ctx, 1, otelAttrs...) - var ( - contentType string - reqBody io.Reader - ) - contentType = "application/json" - buf, err := encodeUpdateUsersRequestJSON(request, span) - if err != nil { - return res, err - } - defer jx.PutEncoder(buf) - reqBody = bytes.NewReader(buf.Bytes()) - u := uri.Clone(c.serverURL) + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) u.Path += "/users/" { // Encode "id" parameter. @@ -544,18 +1803,24 @@ func (c *Client) UpdateUsers(ctx context.Context, request UpdateUsersReq, params u.Path += e.Result() } - r := ht.NewRequest(ctx, "PATCH", u, reqBody) - defer ht.PutRequest(r) - - r.Header.Set("Content-Type", contentType) + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "PATCH", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeUpdateUserRequest(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() - result, err := decodeUpdateUsersResponse(resp, span) + stage = "DecodeResponse" + result, err := decodeUpdateUserResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } diff --git a/ent/ogent/oas_defaults_gen.go b/ent/ogent/oas_defaults_gen.go deleted file mode 100644 index 384bf65..0000000 --- a/ent/ogent/oas_defaults_gen.go +++ /dev/null @@ -1,71 +0,0 @@ -// Code generated by ogen, DO NOT EDIT. - -package ogent - -import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" -) - -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) diff --git a/ent/ogent/oas_handlers_gen.go b/ent/ogent/oas_handlers_gen.go index 55e1034..073e812 100644 --- a/ent/ogent/oas_handlers_gen.go +++ b/ent/ogent/oas_handlers_gen.go @@ -3,388 +3,2129 @@ package ogent import ( - "bytes" "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" "time" - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" + semconv "go.opentelemetry.io/otel/semconv/v1.17.0" "go.opentelemetry.io/otel/trace" + + "github.com/ogen-go/ogen/middleware" + "github.com/ogen-go/ogen/ogenerrors" + "github.com/ogen-go/ogen/otelogen" ) -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) +// handleCreateCardRequest handles createCard operation. +// +// Creates a new Card and persists it to storage. +// +// POST /cards +func (s *Server) handleCreateCardRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("createCard"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/cards"), + } -// HandleCreateUsersRequest handles createUsers operation. + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateCard", + 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: "CreateCard", + ID: "createCard", + } + ) + request, close, err := s.decodeCreateCardRequest(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 CreateCardRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "CreateCard", + OperationID: "createCard", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = *CreateCardReq + Params = struct{} + Response = CreateCardRes + ) + 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.CreateCard(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.CreateCard(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeCreateCardResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleCreateGroupRequest handles createGroup operation. +// +// Creates a new Group and persists it to storage. +// +// POST /groups +func (s *Server) handleCreateGroupRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("createGroup"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/groups"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateGroup", + 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: "CreateGroup", + ID: "createGroup", + } + ) + request, close, err := s.decodeCreateGroupRequest(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 CreateGroupRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "CreateGroup", + OperationID: "createGroup", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = *CreateGroupReq + Params = struct{} + Response = CreateGroupRes + ) + 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.CreateGroup(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.CreateGroup(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeCreateGroupResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleCreateUserRequest handles createUser operation. +// +// Creates a new User and persists it to storage. // // POST /users -func (s *Server) handleCreateUsersRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - startTime := time.Now() +func (s *Server) handleCreateUserRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("createUsers"), + otelogen.OperationID("createUser"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/users"), } - ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateUsers", + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateUser", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), + serverSpanKind, ) - s.requests.Add(ctx, 1, otelAttrs...) defer span.End() - var err error - request, err := decodeCreateUsersRequest(r, span) + // 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: "CreateUser", + ID: "createUser", + } + ) + request, close, err := s.decodeCreateUserRequest(r) if err != nil { - s.badRequest(ctx, w, span, otelAttrs, err) + 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 CreateUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "CreateUser", + OperationID: "createUser", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = *CreateUserReq + Params = struct{} + Response = CreateUserRes + ) + 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.CreateUser(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.CreateUser(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - response, err := s.h.CreateUsers(ctx, request) - if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Internal") - s.errors.Add(ctx, 1, otelAttrs...) - respondError(w, http.StatusInternalServerError, err) + if err := encodeCreateUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - - if err := encodeCreateUsersResponse(response, w, span); err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Response") - s.errors.Add(ctx, 1, otelAttrs...) - return - } - span.SetStatus(codes.Ok, "Ok") - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } -// HandleDeleteUsersRequest handles deleteUsers operation. +// handleDeleteCardRequest handles deleteCard operation. +// +// Deletes the Card with the requested ID. +// +// DELETE /cards/{id} +func (s *Server) handleDeleteCardRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deleteCard"), + semconv.HTTPMethodKey.String("DELETE"), + semconv.HTTPRouteKey.String("/cards/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "DeleteCard", + 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: "DeleteCard", + ID: "deleteCard", + } + ) + params, err := decodeDeleteCardParams(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 DeleteCardRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "DeleteCard", + OperationID: "deleteCard", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = DeleteCardParams + Response = DeleteCardRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackDeleteCardParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.DeleteCard(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.DeleteCard(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeDeleteCardResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleDeleteGroupRequest handles deleteGroup operation. +// +// Deletes the Group with the requested ID. +// +// DELETE /groups/{id} +func (s *Server) handleDeleteGroupRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deleteGroup"), + semconv.HTTPMethodKey.String("DELETE"), + semconv.HTTPRouteKey.String("/groups/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "DeleteGroup", + 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: "DeleteGroup", + ID: "deleteGroup", + } + ) + params, err := decodeDeleteGroupParams(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 DeleteGroupRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "DeleteGroup", + OperationID: "deleteGroup", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = DeleteGroupParams + Response = DeleteGroupRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackDeleteGroupParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.DeleteGroup(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.DeleteGroup(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeDeleteGroupResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleDeleteUserRequest handles deleteUser operation. +// +// Deletes the User with the requested ID. // // DELETE /users/{id} -func (s *Server) handleDeleteUsersRequest(args [1]string, w http.ResponseWriter, r *http.Request) { - startTime := time.Now() +func (s *Server) handleDeleteUserRequest(args [1]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("deleteUsers"), + otelogen.OperationID("deleteUser"), + semconv.HTTPMethodKey.String("DELETE"), + semconv.HTTPRouteKey.String("/users/{id}"), } - ctx, span := s.cfg.Tracer.Start(r.Context(), "DeleteUsers", + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "DeleteUser", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), + serverSpanKind, ) - s.requests.Add(ctx, 1, otelAttrs...) defer span.End() - var err error - params, err := decodeDeleteUsersParams(args, r) + // 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: "DeleteUser", + ID: "deleteUser", + } + ) + params, err := decodeDeleteUserParams(args, r) if err != nil { - s.badRequest(ctx, w, span, otelAttrs, err) + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - response, err := s.h.DeleteUsers(ctx, params) + var response DeleteUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "DeleteUser", + OperationID: "deleteUser", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = DeleteUserParams + Response = DeleteUserRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackDeleteUserParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.DeleteUser(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.DeleteUser(ctx, params) + } if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Internal") - s.errors.Add(ctx, 1, otelAttrs...) - respondError(w, http.StatusInternalServerError, err) + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - if err := encodeDeleteUsersResponse(response, w, span); err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Response") - s.errors.Add(ctx, 1, otelAttrs...) + if err := encodeDeleteUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - span.SetStatus(codes.Ok, "Ok") - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } -// HandleDrawDoneRequest handles drawDone operation. +// handleDrawDoneRequest handles drawDone operation. // -// PUT /users/{id}/d +// Draws a card item as done. +// +// PUT /cards/{id}/d func (s *Server) handleDrawDoneRequest(args [1]string, w http.ResponseWriter, r *http.Request) { - startTime := time.Now() otelAttrs := []attribute.KeyValue{ otelogen.OperationID("drawDone"), + semconv.HTTPMethodKey.String("PUT"), + semconv.HTTPRouteKey.String("/cards/{id}/d"), } + + // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), "DrawDone", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), + serverSpanKind, ) - s.requests.Add(ctx, 1, otelAttrs...) defer span.End() - var err error + // 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: "DrawDone", + ID: "drawDone", + } + ) params, err := decodeDrawDoneParams(args, r) if err != nil { - s.badRequest(ctx, w, span, otelAttrs, err) + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - response, err := s.h.DrawDone(ctx, params) + var response *DrawDoneNoContent + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "DrawDone", + OperationID: "drawDone", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = DrawDoneParams + Response = *DrawDoneNoContent + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackDrawDoneParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + err = s.h.DrawDone(ctx, params) + return response, err + }, + ) + } else { + err = s.h.DrawDone(ctx, params) + } if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Internal") - s.errors.Add(ctx, 1, otelAttrs...) - respondError(w, http.StatusInternalServerError, err) + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeDrawDoneResponse(response, w, span); err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Response") - s.errors.Add(ctx, 1, otelAttrs...) + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - span.SetStatus(codes.Ok, "Ok") - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } -// HandleDrawStartRequest handles drawStart operation. +// handleDrawStartRequest handles drawStart operation. // -// PATCH /users/{id}/start +// Draws a card item as done. +// +// PATCH /users/{id}/card/start func (s *Server) handleDrawStartRequest(args [1]string, w http.ResponseWriter, r *http.Request) { - startTime := time.Now() otelAttrs := []attribute.KeyValue{ otelogen.OperationID("drawStart"), + semconv.HTTPMethodKey.String("PATCH"), + semconv.HTTPRouteKey.String("/users/{id}/card/start"), } + + // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), "DrawStart", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), + serverSpanKind, ) - s.requests.Add(ctx, 1, otelAttrs...) defer span.End() - var err error + // 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: "DrawStart", + ID: "drawStart", + } + ) params, err := decodeDrawStartParams(args, r) if err != nil { - s.badRequest(ctx, w, span, otelAttrs, err) + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - response, err := s.h.DrawStart(ctx, params) + var response *DrawStartNoContent + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "DrawStart", + OperationID: "drawStart", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = DrawStartParams + Response = *DrawStartNoContent + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackDrawStartParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + err = s.h.DrawStart(ctx, params) + return response, err + }, + ) + } else { + err = s.h.DrawStart(ctx, params) + } if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Internal") - s.errors.Add(ctx, 1, otelAttrs...) - respondError(w, http.StatusInternalServerError, err) + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeDrawStartResponse(response, w, span); err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Response") - s.errors.Add(ctx, 1, otelAttrs...) + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - span.SetStatus(codes.Ok, "Ok") - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } -// HandleListUsersRequest handles listUsers operation. +// handleListCardRequest handles listCard operation. +// +// List Cards. +// +// GET /cards +func (s *Server) handleListCardRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listCard"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/cards"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ListCard", + 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: "ListCard", + ID: "listCard", + } + ) + params, err := decodeListCardParams(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 ListCardRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ListCard", + OperationID: "listCard", + Body: nil, + Params: middleware.Parameters{ + { + Name: "page", + In: "query", + }: params.Page, + { + Name: "itemsPerPage", + In: "query", + }: params.ItemsPerPage, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ListCardParams + Response = ListCardRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackListCardParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ListCard(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ListCard(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeListCardResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleListGroupRequest handles listGroup operation. +// +// List Groups. +// +// GET /groups +func (s *Server) handleListGroupRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listGroup"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/groups"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ListGroup", + 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: "ListGroup", + ID: "listGroup", + } + ) + params, err := decodeListGroupParams(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 ListGroupRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ListGroup", + OperationID: "listGroup", + Body: nil, + Params: middleware.Parameters{ + { + Name: "page", + In: "query", + }: params.Page, + { + Name: "itemsPerPage", + In: "query", + }: params.ItemsPerPage, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ListGroupParams + Response = ListGroupRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackListGroupParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ListGroup(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ListGroup(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeListGroupResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleListGroupUsersRequest handles listGroupUsers operation. +// +// List attached Users. +// +// GET /groups/{id}/users +func (s *Server) handleListGroupUsersRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listGroupUsers"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/groups/{id}/users"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ListGroupUsers", + 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: "ListGroupUsers", + ID: "listGroupUsers", + } + ) + params, err := decodeListGroupUsersParams(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 ListGroupUsersRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ListGroupUsers", + OperationID: "listGroupUsers", + 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 = ListGroupUsersParams + Response = ListGroupUsersRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackListGroupUsersParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ListGroupUsers(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ListGroupUsers(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeListGroupUsersResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleListUserRequest handles listUser operation. +// +// List Users. // // GET /users -func (s *Server) handleListUsersRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - startTime := time.Now() +func (s *Server) handleListUserRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("listUsers"), + otelogen.OperationID("listUser"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/users"), } - ctx, span := s.cfg.Tracer.Start(r.Context(), "ListUsers", + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ListUser", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), + serverSpanKind, ) - s.requests.Add(ctx, 1, otelAttrs...) defer span.End() - var err error - params, err := decodeListUsersParams(args, r) + // 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: "ListUser", + ID: "listUser", + } + ) + params, err := decodeListUserParams(args, r) if err != nil { - s.badRequest(ctx, w, span, otelAttrs, err) + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - response, err := s.h.ListUsers(ctx, params) + var response ListUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ListUser", + OperationID: "listUser", + Body: nil, + Params: middleware.Parameters{ + { + Name: "page", + In: "query", + }: params.Page, + { + Name: "itemsPerPage", + In: "query", + }: params.ItemsPerPage, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ListUserParams + Response = ListUserRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackListUserParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ListUser(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ListUser(ctx, params) + } if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Internal") - s.errors.Add(ctx, 1, otelAttrs...) - respondError(w, http.StatusInternalServerError, err) + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - if err := encodeListUsersResponse(response, w, span); err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Response") - s.errors.Add(ctx, 1, otelAttrs...) + if err := encodeListUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - span.SetStatus(codes.Ok, "Ok") - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } -// HandleReadUsersRequest handles readUsers operation. +// handleListUserCardRequest handles listUserCard operation. +// +// List attached Cards. +// +// GET /users/{id}/card +func (s *Server) handleListUserCardRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listUserCard"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/users/{id}/card"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ListUserCard", + 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: "ListUserCard", + ID: "listUserCard", + } + ) + params, err := decodeListUserCardParams(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 ListUserCardRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ListUserCard", + OperationID: "listUserCard", + 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 = ListUserCardParams + Response = ListUserCardRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackListUserCardParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ListUserCard(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ListUserCard(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeListUserCardResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleReadCardRequest handles readCard operation. +// +// Finds the Card with the requested ID and returns it. +// +// GET /cards/{id} +func (s *Server) handleReadCardRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readCard"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/cards/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadCard", + 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: "ReadCard", + ID: "readCard", + } + ) + params, err := decodeReadCardParams(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 ReadCardRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ReadCard", + OperationID: "readCard", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ReadCardParams + Response = ReadCardRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackReadCardParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ReadCard(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ReadCard(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeReadCardResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleReadCardOwnerRequest handles readCardOwner operation. +// +// Find the attached User of the Card with the given ID. +// +// GET /cards/{id}/owner +func (s *Server) handleReadCardOwnerRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readCardOwner"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/cards/{id}/owner"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadCardOwner", + 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: "ReadCardOwner", + ID: "readCardOwner", + } + ) + params, err := decodeReadCardOwnerParams(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 ReadCardOwnerRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ReadCardOwner", + OperationID: "readCardOwner", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ReadCardOwnerParams + Response = ReadCardOwnerRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackReadCardOwnerParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ReadCardOwner(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ReadCardOwner(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeReadCardOwnerResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleReadGroupRequest handles readGroup operation. +// +// Finds the Group with the requested ID and returns it. +// +// GET /groups/{id} +func (s *Server) handleReadGroupRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readGroup"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/groups/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadGroup", + 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: "ReadGroup", + ID: "readGroup", + } + ) + params, err := decodeReadGroupParams(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 ReadGroupRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ReadGroup", + OperationID: "readGroup", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ReadGroupParams + Response = ReadGroupRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackReadGroupParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ReadGroup(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ReadGroup(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeReadGroupResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleReadUserRequest handles readUser operation. +// +// Finds the User with the requested ID and returns it. // // GET /users/{id} -func (s *Server) handleReadUsersRequest(args [1]string, w http.ResponseWriter, r *http.Request) { - startTime := time.Now() +func (s *Server) handleReadUserRequest(args [1]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("readUsers"), + otelogen.OperationID("readUser"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/users/{id}"), } - ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadUsers", + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadUser", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), + serverSpanKind, ) - s.requests.Add(ctx, 1, otelAttrs...) defer span.End() - var err error - params, err := decodeReadUsersParams(args, r) + // 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: "ReadUser", + ID: "readUser", + } + ) + params, err := decodeReadUserParams(args, r) if err != nil { - s.badRequest(ctx, w, span, otelAttrs, err) + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - response, err := s.h.ReadUsers(ctx, params) + var response ReadUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ReadUser", + OperationID: "readUser", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ReadUserParams + Response = ReadUserRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackReadUserParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ReadUser(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ReadUser(ctx, params) + } if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Internal") - s.errors.Add(ctx, 1, otelAttrs...) - respondError(w, http.StatusInternalServerError, err) + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - if err := encodeReadUsersResponse(response, w, span); err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Response") - s.errors.Add(ctx, 1, otelAttrs...) + if err := encodeReadUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - span.SetStatus(codes.Ok, "Ok") - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) } -// HandleUpdateUsersRequest handles updateUsers operation. +// handleUpdateCardRequest handles updateCard operation. +// +// Updates a Card and persists changes to storage. +// +// PATCH /cards/{id} +func (s *Server) handleUpdateCardRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("updateCard"), + semconv.HTTPMethodKey.String("PATCH"), + semconv.HTTPRouteKey.String("/cards/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdateCard", + 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: "UpdateCard", + ID: "updateCard", + } + ) + params, err := decodeUpdateCardParams(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.decodeUpdateCardRequest(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 UpdateCardRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "UpdateCard", + OperationID: "updateCard", + Body: request, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = *UpdateCardReq + Params = UpdateCardParams + Response = UpdateCardRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackUpdateCardParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.UpdateCard(ctx, request, params) + return response, err + }, + ) + } else { + response, err = s.h.UpdateCard(ctx, request, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeUpdateCardResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleUpdateGroupRequest handles updateGroup operation. +// +// Updates a Group and persists changes to storage. +// +// PATCH /groups/{id} +func (s *Server) handleUpdateGroupRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("updateGroup"), + semconv.HTTPMethodKey.String("PATCH"), + semconv.HTTPRouteKey.String("/groups/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdateGroup", + 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: "UpdateGroup", + ID: "updateGroup", + } + ) + params, err := decodeUpdateGroupParams(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.decodeUpdateGroupRequest(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 UpdateGroupRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "UpdateGroup", + OperationID: "updateGroup", + Body: request, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = *UpdateGroupReq + Params = UpdateGroupParams + Response = UpdateGroupRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackUpdateGroupParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.UpdateGroup(ctx, request, params) + return response, err + }, + ) + } else { + response, err = s.h.UpdateGroup(ctx, request, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeUpdateGroupResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleUpdateUserRequest handles updateUser operation. +// +// Updates a User and persists changes to storage. // // PATCH /users/{id} -func (s *Server) handleUpdateUsersRequest(args [1]string, w http.ResponseWriter, r *http.Request) { - startTime := time.Now() +func (s *Server) handleUpdateUserRequest(args [1]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("updateUsers"), + otelogen.OperationID("updateUser"), + semconv.HTTPMethodKey.String("PATCH"), + semconv.HTTPRouteKey.String("/users/{id}"), } - ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdateUsers", + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdateUser", trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), + serverSpanKind, ) - s.requests.Add(ctx, 1, otelAttrs...) defer span.End() - var err error - params, err := decodeUpdateUsersParams(args, r) + // 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: "UpdateUser", + ID: "updateUser", + } + ) + params, err := decodeUpdateUserParams(args, r) if err != nil { - s.badRequest(ctx, w, span, otelAttrs, err) + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - request, err := decodeUpdateUsersRequest(r, span) + request, close, err := s.decodeUpdateUserRequest(r) if err != nil { - s.badRequest(ctx, w, span, otelAttrs, err) + 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) + } + }() - response, err := s.h.UpdateUsers(ctx, request, params) + var response UpdateUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "UpdateUser", + OperationID: "updateUser", + Body: request, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = *UpdateUserReq + Params = UpdateUserParams + Response = UpdateUserRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackUpdateUserParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.UpdateUser(ctx, request, params) + return response, err + }, + ) + } else { + response, err = s.h.UpdateUser(ctx, request, params) + } if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Internal") - s.errors.Add(ctx, 1, otelAttrs...) - respondError(w, http.StatusInternalServerError, err) + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - if err := encodeUpdateUsersResponse(response, w, span); err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, "Response") - s.errors.Add(ctx, 1, otelAttrs...) + if err := encodeUpdateUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) return } - span.SetStatus(codes.Ok, "Ok") - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) -} - -func (s *Server) badRequest(ctx context.Context, w http.ResponseWriter, span trace.Span, otelAttrs []attribute.KeyValue, err error) { - span.RecordError(err) - span.SetStatus(codes.Error, "BadRequest") - s.errors.Add(ctx, 1, otelAttrs...) - respondError(w, http.StatusBadRequest, err) -} - -func respondError(w http.ResponseWriter, code int, err error) { - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(code) - data, writeErr := json.Marshal(struct { - ErrorMessage string `json:"error_message"` - }{ - ErrorMessage: err.Error(), - }) - if writeErr == nil { - w.Write(data) - } } diff --git a/ent/ogent/oas_interfaces_gen.go b/ent/ogent/oas_interfaces_gen.go index c9afc96..eec23f9 100644 --- a/ent/ogent/oas_interfaces_gen.go +++ b/ent/ogent/oas_interfaces_gen.go @@ -1,22 +1,74 @@ // Code generated by ogen, DO NOT EDIT. package ogent -type CreateUsersRes interface { - createUsersRes() +type CreateCardRes interface { + createCardRes() } -type DeleteUsersRes interface { - deleteUsersRes() +type CreateGroupRes interface { + createGroupRes() } -type ListUsersRes interface { - listUsersRes() +type CreateUserRes interface { + createUserRes() } -type ReadUsersRes interface { - readUsersRes() +type DeleteCardRes interface { + deleteCardRes() } -type UpdateUsersRes interface { - updateUsersRes() +type DeleteGroupRes interface { + deleteGroupRes() +} + +type DeleteUserRes interface { + deleteUserRes() +} + +type ListCardRes interface { + listCardRes() +} + +type ListGroupRes interface { + listGroupRes() +} + +type ListGroupUsersRes interface { + listGroupUsersRes() +} + +type ListUserCardRes interface { + listUserCardRes() +} + +type ListUserRes interface { + listUserRes() +} + +type ReadCardOwnerRes interface { + readCardOwnerRes() +} + +type ReadCardRes interface { + readCardRes() +} + +type ReadGroupRes interface { + readGroupRes() +} + +type ReadUserRes interface { + readUserRes() +} + +type UpdateCardRes interface { + updateCardRes() +} + +type UpdateGroupRes interface { + updateGroupRes() +} + +type UpdateUserRes interface { + updateUserRes() } diff --git a/ent/ogent/oas_json_gen.go b/ent/ogent/oas_json_gen.go index 79344dd..bb1a54a 100644 --- a/ent/ogent/oas_json_gen.go +++ b/ent/ogent/oas_json_gen.go @@ -3,151 +3,35 @@ package ogent import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" "strconv" - "strings" - "sync" "time" "github.com/go-faster/errors" "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" -) -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset + "github.com/ogen-go/ogen/json" + "github.com/ogen-go/ogen/validate" ) // Encode implements json.Marshaler. -func (s CreateUsersReq) Encode(e *jx.Encoder) { +func (s *CardCreate) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s CreateUsersReq) encodeFields(e *jx.Encoder) { +// encodeFields encodes fields. +func (s *CardCreate) encodeFields(e *jx.Encoder) { { - e.FieldStart("user") - e.Str(s.User) + e.FieldStart("id") + e.Int(s.ID) } { - if s.Chara.Set { - e.FieldStart("chara") - s.Chara.Encode(e) - } - } - { - if s.Skill.Set { - e.FieldStart("skill") - s.Skill.Encode(e) - } - } - { - if s.Hp.Set { - e.FieldStart("hp") - s.Hp.Encode(e) - } - } - { - if s.Attack.Set { - e.FieldStart("attack") - s.Attack.Encode(e) - } - } - { - if s.Defense.Set { - e.FieldStart("defense") - s.Defense.Encode(e) - } - } - { - if s.Critical.Set { - e.FieldStart("critical") - s.Critical.Encode(e) - } - } - { - if s.Battle.Set { - e.FieldStart("battle") - s.Battle.Encode(e) - } - } - { - if s.Win.Set { - e.FieldStart("win") - s.Win.Encode(e) - } - } - { - if s.Day.Set { - e.FieldStart("day") - s.Day.Encode(e) - } - } - { - if s.Percentage.Set { - e.FieldStart("percentage") - s.Percentage.Encode(e) - } - } - { - if s.Limit.Set { - e.FieldStart("limit") - s.Limit.Encode(e) + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) } } { @@ -157,27 +41,9 @@ func (s CreateUsersReq) encodeFields(e *jx.Encoder) { } } { - if s.Comment.Set { - e.FieldStart("comment") - s.Comment.Encode(e) - } - } - { - if s.CreatedAt.Set { - e.FieldStart("created_at") - s.CreatedAt.Encode(e, json.EncodeDateTime) - } - } - { - if s.Next.Set { - e.FieldStart("next") - s.Next.Encode(e) - } - } - { - if s.UpdatedAt.Set { - e.FieldStart("updated_at") - s.UpdatedAt.Encode(e, json.EncodeDateTime) + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) } } { @@ -186,159 +52,53 @@ func (s CreateUsersReq) encodeFields(e *jx.Encoder) { s.URL.Encode(e) } } -} - -var jsonFieldsNameOfCreateUsersReq = [18]string{ - 0: "user", - 1: "chara", - 2: "skill", - 3: "hp", - 4: "attack", - 5: "defense", - 6: "critical", - 7: "battle", - 8: "win", - 9: "day", - 10: "percentage", - 11: "limit", - 12: "status", - 13: "comment", - 14: "created_at", - 15: "next", - 16: "updated_at", - 17: "url", -} - -// Decode decodes CreateUsersReq from json. -func (s *CreateUsersReq) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode CreateUsersReq to nil") + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } } - var requiredBitSet [3]uint8 +} + +var jsonFieldsNameOfCardCreate = [6]string{ + 0: "id", + 1: "card", + 2: "status", + 3: "cp", + 4: "url", + 5: "created_at", +} + +// Decode decodes CardCreate from json. +func (s *CardCreate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CardCreate to nil") + } + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "user": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.User = string(v) + v, err := d.Int() + s.ID = int(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"user\"") + return errors.Wrap(err, "decode field \"id\"") } - case "chara": + case "card": if err := func() error { - s.Chara.Reset() - if err := s.Chara.Decode(d); err != nil { + s.Card.Reset() + if err := s.Card.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"chara\"") - } - case "skill": - if err := func() error { - s.Skill.Reset() - if err := s.Skill.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"skill\"") - } - case "hp": - if err := func() error { - s.Hp.Reset() - if err := s.Hp.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"hp\"") - } - case "attack": - if err := func() error { - s.Attack.Reset() - if err := s.Attack.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"attack\"") - } - case "defense": - if err := func() error { - s.Defense.Reset() - if err := s.Defense.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"defense\"") - } - case "critical": - if err := func() error { - s.Critical.Reset() - if err := s.Critical.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"critical\"") - } - case "battle": - if err := func() error { - s.Battle.Reset() - if err := s.Battle.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"battle\"") - } - case "win": - if err := func() error { - s.Win.Reset() - if err := s.Win.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"win\"") - } - case "day": - if err := func() error { - s.Day.Reset() - if err := s.Day.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"day\"") - } - case "percentage": - if err := func() error { - s.Percentage.Reset() - if err := s.Percentage.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"percentage\"") - } - 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\"") + return errors.Wrap(err, "decode field \"card\"") } case "status": if err := func() error { @@ -350,45 +110,15 @@ func (s *CreateUsersReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"status\"") } - case "comment": + case "cp": if err := func() error { - s.Comment.Reset() - if err := s.Comment.Decode(d); err != nil { + s.Cp.Reset() + if err := s.Cp.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"comment\"") - } - 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 "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 "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\"") + return errors.Wrap(err, "decode field \"cp\"") } case "url": if err := func() error { @@ -400,19 +130,27 @@ func (s *CreateUsersReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"url\"") } + 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 CreateUsersReq") + return errors.Wrap(err, "decode CardCreate") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [3]uint8{ + for i, mask := range [1]uint8{ 0b00000001, - 0b00000000, - 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -424,8 +162,8 @@ func (s *CreateUsersReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfCreateUsersReq) { - name = jsonFieldsNameOfCreateUsersReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfCardCreate) { + name = jsonFieldsNameOfCardCreate[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -445,9 +183,1848 @@ func (s *CreateUsersReq) Decode(d *jx.Decoder) error { return nil } -// Encode encodes ListUsersOKApplicationJSON as json. -func (s ListUsersOKApplicationJSON) Encode(e *jx.Encoder) { - unwrapped := []UsersList(s) +// MarshalJSON implements stdjson.Marshaler. +func (s *CardCreate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CardCreate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CardList) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CardList) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.Status.Set { + e.FieldStart("status") + s.Status.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.URL.Set { + e.FieldStart("url") + s.URL.Encode(e) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } +} + +var jsonFieldsNameOfCardList = [6]string{ + 0: "id", + 1: "card", + 2: "status", + 3: "cp", + 4: "url", + 5: "created_at", +} + +// Decode decodes CardList from json. +func (s *CardList) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CardList to nil") + } + var requiredBitSet [1]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 "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 "status": + if err := func() error { + s.Status.Reset() + if err := s.Status.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + 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 "url": + if err := func() error { + s.URL.Reset() + if err := s.URL.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"url\"") + } + 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 CardList") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + 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(jsonFieldsNameOfCardList) { + name = jsonFieldsNameOfCardList[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 *CardList) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CardList) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CardOwnerRead) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CardOwnerRead) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("username") + e.Str(s.Username) + } + { + 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.Next.Set { + e.FieldStart("next") + s.Next.Encode(e) + } + } +} + +var jsonFieldsNameOfCardOwnerRead = [5]string{ + 0: "id", + 1: "username", + 2: "created_at", + 3: "updated_at", + 4: "next", +} + +// Decode decodes CardOwnerRead from json. +func (s *CardOwnerRead) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CardOwnerRead to nil") + } + var requiredBitSet [1]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 "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 "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\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CardOwnerRead") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + 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(jsonFieldsNameOfCardOwnerRead) { + name = jsonFieldsNameOfCardOwnerRead[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 *CardOwnerRead) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CardOwnerRead) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CardRead) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CardRead) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.Status.Set { + e.FieldStart("status") + s.Status.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.URL.Set { + e.FieldStart("url") + s.URL.Encode(e) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } +} + +var jsonFieldsNameOfCardRead = [6]string{ + 0: "id", + 1: "card", + 2: "status", + 3: "cp", + 4: "url", + 5: "created_at", +} + +// Decode decodes CardRead from json. +func (s *CardRead) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CardRead to nil") + } + var requiredBitSet [1]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 "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 "status": + if err := func() error { + s.Status.Reset() + if err := s.Status.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + 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 "url": + if err := func() error { + s.URL.Reset() + if err := s.URL.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"url\"") + } + 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 CardRead") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + 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(jsonFieldsNameOfCardRead) { + name = jsonFieldsNameOfCardRead[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 *CardRead) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CardRead) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CardUpdate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CardUpdate) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.Status.Set { + e.FieldStart("status") + s.Status.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.URL.Set { + e.FieldStart("url") + s.URL.Encode(e) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } +} + +var jsonFieldsNameOfCardUpdate = [6]string{ + 0: "id", + 1: "card", + 2: "status", + 3: "cp", + 4: "url", + 5: "created_at", +} + +// Decode decodes CardUpdate from json. +func (s *CardUpdate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CardUpdate to nil") + } + var requiredBitSet [1]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 "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 "status": + if err := func() error { + s.Status.Reset() + if err := s.Status.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + 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 "url": + if err := func() error { + s.URL.Reset() + if err := s.URL.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"url\"") + } + 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 CardUpdate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + 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(jsonFieldsNameOfCardUpdate) { + name = jsonFieldsNameOfCardUpdate[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 *CardUpdate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CardUpdate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CreateCardReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CreateCardReq) encodeFields(e *jx.Encoder) { + { + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) + } + } + { + if s.Status.Set { + e.FieldStart("status") + s.Status.Encode(e) + } + } + { + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) + } + } + { + if s.URL.Set { + e.FieldStart("url") + s.URL.Encode(e) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } + { + + e.FieldStart("owner") + e.Int(s.Owner) + } +} + +var jsonFieldsNameOfCreateCardReq = [6]string{ + 0: "card", + 1: "status", + 2: "cp", + 3: "url", + 4: "created_at", + 5: "owner", +} + +// Decode decodes CreateCardReq from json. +func (s *CreateCardReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreateCardReq to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + 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 "status": + if err := func() error { + s.Status.Reset() + if err := s.Status.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + 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 "url": + if err := func() error { + s.URL.Reset() + if err := s.URL.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"url\"") + } + 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[0] |= 1 << 5 + 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 CreateCardReq") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00100000, + } { + 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(jsonFieldsNameOfCreateCardReq) { + name = jsonFieldsNameOfCreateCardReq[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 *CreateCardReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreateCardReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CreateGroupReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CreateGroupReq) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("name") + e.Str(s.Name) + } + { + if s.Users != nil { + e.FieldStart("users") + e.ArrStart() + for _, elem := range s.Users { + e.Int(elem) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfCreateGroupReq = [2]string{ + 0: "name", + 1: "users", +} + +// Decode decodes CreateGroupReq from json. +func (s *CreateGroupReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreateGroupReq to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "name": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "users": + if err := func() error { + s.Users = 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.Users = append(s.Users, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"users\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CreateGroupReq") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + 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(jsonFieldsNameOfCreateGroupReq) { + name = jsonFieldsNameOfCreateGroupReq[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 *CreateGroupReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreateGroupReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CreateUserReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CreateUserReq) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("username") + e.Str(s.Username) + } + { + 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.Next.Set { + e.FieldStart("next") + s.Next.Encode(e) + } + } + { + if s.Card != nil { + e.FieldStart("card") + e.ArrStart() + for _, elem := range s.Card { + e.Int(elem) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfCreateUserReq = [5]string{ + 0: "username", + 1: "created_at", + 2: "updated_at", + 3: "next", + 4: "card", +} + +// Decode decodes CreateUserReq from json. +func (s *CreateUserReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreateUserReq to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "username": + requiredBitSet[0] |= 1 << 0 + 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 "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 "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 "card": + if err := func() error { + s.Card = 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.Card = append(s.Card, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"card\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CreateUserReq") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000001, + } { + 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(jsonFieldsNameOfCreateUserReq) { + name = jsonFieldsNameOfCreateUserReq[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 *CreateUserReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreateUserReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GroupCreate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GroupCreate) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("name") + e.Str(s.Name) + } +} + +var jsonFieldsNameOfGroupCreate = [2]string{ + 0: "id", + 1: "name", +} + +// Decode decodes GroupCreate from json. +func (s *GroupCreate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GroupCreate to nil") + } + var requiredBitSet [1]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 "name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode GroupCreate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + 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(jsonFieldsNameOfGroupCreate) { + name = jsonFieldsNameOfGroupCreate[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 *GroupCreate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GroupCreate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GroupList) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GroupList) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("name") + e.Str(s.Name) + } +} + +var jsonFieldsNameOfGroupList = [2]string{ + 0: "id", + 1: "name", +} + +// Decode decodes GroupList from json. +func (s *GroupList) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GroupList to nil") + } + var requiredBitSet [1]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 "name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode GroupList") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + 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(jsonFieldsNameOfGroupList) { + name = jsonFieldsNameOfGroupList[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 *GroupList) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GroupList) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GroupRead) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GroupRead) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("name") + e.Str(s.Name) + } +} + +var jsonFieldsNameOfGroupRead = [2]string{ + 0: "id", + 1: "name", +} + +// Decode decodes GroupRead from json. +func (s *GroupRead) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GroupRead to nil") + } + var requiredBitSet [1]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 "name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode GroupRead") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + 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(jsonFieldsNameOfGroupRead) { + name = jsonFieldsNameOfGroupRead[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 *GroupRead) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GroupRead) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GroupUpdate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GroupUpdate) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("name") + e.Str(s.Name) + } +} + +var jsonFieldsNameOfGroupUpdate = [2]string{ + 0: "id", + 1: "name", +} + +// Decode decodes GroupUpdate from json. +func (s *GroupUpdate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GroupUpdate to nil") + } + var requiredBitSet [1]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 "name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode GroupUpdate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + 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(jsonFieldsNameOfGroupUpdate) { + name = jsonFieldsNameOfGroupUpdate[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 *GroupUpdate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GroupUpdate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GroupUsersList) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GroupUsersList) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("username") + e.Str(s.Username) + } + { + 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.Next.Set { + e.FieldStart("next") + s.Next.Encode(e) + } + } +} + +var jsonFieldsNameOfGroupUsersList = [5]string{ + 0: "id", + 1: "username", + 2: "created_at", + 3: "updated_at", + 4: "next", +} + +// Decode decodes GroupUsersList from json. +func (s *GroupUsersList) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GroupUsersList to nil") + } + var requiredBitSet [1]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 "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 "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\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode GroupUsersList") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + 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(jsonFieldsNameOfGroupUsersList) { + name = jsonFieldsNameOfGroupUsersList[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 *GroupUsersList) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GroupUsersList) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ListCardOKApplicationJSON as json. +func (s ListCardOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := []CardList(s) + e.ArrStart() for _, elem := range unwrapped { elem.Encode(e) @@ -455,16 +2032,16 @@ func (s ListUsersOKApplicationJSON) Encode(e *jx.Encoder) { e.ArrEnd() } -// Decode decodes ListUsersOKApplicationJSON from json. -func (s *ListUsersOKApplicationJSON) Decode(d *jx.Decoder) error { +// Decode decodes ListCardOKApplicationJSON from json. +func (s *ListCardOKApplicationJSON) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ListUsersOKApplicationJSON to nil") + return errors.New("invalid: unable to decode ListCardOKApplicationJSON to nil") } - var unwrapped []UsersList + var unwrapped []CardList if err := func() error { - unwrapped = make([]UsersList, 0) + unwrapped = make([]CardList, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem UsersList + var elem CardList if err := elem.Decode(d); err != nil { return err } @@ -477,32 +2054,223 @@ func (s *ListUsersOKApplicationJSON) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "alias") } - *s = ListUsersOKApplicationJSON(unwrapped) + *s = ListCardOKApplicationJSON(unwrapped) return nil } -// Encode encodes bool as json. -func (o OptBool) Encode(e *jx.Encoder) { - if !o.Set { - return - } - e.Bool(bool(o.Value)) +// MarshalJSON implements stdjson.Marshaler. +func (s ListCardOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil } -// Decode decodes bool from json. -func (o *OptBool) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptBool to nil") +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListCardOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ListGroupOKApplicationJSON as json. +func (s ListGroupOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := []GroupList(s) + + e.ArrStart() + for _, elem := range unwrapped { + elem.Encode(e) } - o.Set = true - v, err := d.Bool() - if err != nil { - return err + e.ArrEnd() +} + +// Decode decodes ListGroupOKApplicationJSON from json. +func (s *ListGroupOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListGroupOKApplicationJSON to nil") } - o.Value = bool(v) + var unwrapped []GroupList + if err := func() error { + unwrapped = make([]GroupList, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GroupList + 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 = ListGroupOKApplicationJSON(unwrapped) return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s ListGroupOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListGroupOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ListGroupUsersOKApplicationJSON as json. +func (s ListGroupUsersOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := []GroupUsersList(s) + + e.ArrStart() + for _, elem := range unwrapped { + elem.Encode(e) + } + e.ArrEnd() +} + +// Decode decodes ListGroupUsersOKApplicationJSON from json. +func (s *ListGroupUsersOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListGroupUsersOKApplicationJSON to nil") + } + var unwrapped []GroupUsersList + if err := func() error { + unwrapped = make([]GroupUsersList, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GroupUsersList + 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 = ListGroupUsersOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ListGroupUsersOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListGroupUsersOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ListUserCardOKApplicationJSON as json. +func (s ListUserCardOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := []UserCardList(s) + + e.ArrStart() + for _, elem := range unwrapped { + elem.Encode(e) + } + e.ArrEnd() +} + +// Decode decodes ListUserCardOKApplicationJSON from json. +func (s *ListUserCardOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListUserCardOKApplicationJSON to nil") + } + var unwrapped []UserCardList + if err := func() error { + unwrapped = make([]UserCardList, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem UserCardList + 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 = ListUserCardOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ListUserCardOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListUserCardOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ListUserOKApplicationJSON as json. +func (s ListUserOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := []UserList(s) + + e.ArrStart() + for _, elem := range unwrapped { + elem.Encode(e) + } + e.ArrEnd() +} + +// Decode decodes ListUserOKApplicationJSON from json. +func (s *ListUserOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListUserOKApplicationJSON to nil") + } + var unwrapped []UserList + if err := func() error { + unwrapped = make([]UserList, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem UserList + 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 = ListUserOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ListUserOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListUserOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes time.Time as json. func (o OptDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { if !o.Set { @@ -525,26 +2293,17 @@ func (o *OptDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, return nil } -// Encode encodes float64 as json. -func (o OptFloat64) Encode(e *jx.Encoder) { - if !o.Set { - return - } - e.Float64(float64(o.Value)) +// MarshalJSON implements stdjson.Marshaler. +func (s OptDateTime) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e, json.EncodeDateTime) + return e.Bytes(), nil } -// Decode decodes float64 from json. -func (o *OptFloat64) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptFloat64 to nil") - } - o.Set = true - v, err := d.Float64() - if err != nil { - return err - } - o.Value = float64(v) - return nil +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptDateTime) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d, json.DecodeDateTime) } // Encode encodes int as json. @@ -569,6 +2328,19 @@ func (o *OptInt) Decode(d *jx.Decoder) error { return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s OptInt) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptInt) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes string as json. func (o OptString) Encode(e *jx.Encoder) { if !o.Set { @@ -591,15 +2363,28 @@ func (o *OptString) Decode(d *jx.Decoder) error { return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s OptString) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptString) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. -func (s R400) Encode(e *jx.Encoder) { +func (s *R400) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s R400) encodeFields(e *jx.Encoder) { +// encodeFields encodes fields. +func (s *R400) encodeFields(e *jx.Encoder) { { e.FieldStart("code") @@ -712,15 +2497,28 @@ func (s *R400) Decode(d *jx.Decoder) error { return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s *R400) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *R400) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. -func (s R404) Encode(e *jx.Encoder) { +func (s *R404) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s R404) encodeFields(e *jx.Encoder) { +// encodeFields encodes fields. +func (s *R404) encodeFields(e *jx.Encoder) { { e.FieldStart("code") @@ -833,15 +2631,28 @@ func (s *R404) Decode(d *jx.Decoder) error { return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s *R404) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *R404) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. -func (s R409) Encode(e *jx.Encoder) { +func (s *R409) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s R409) encodeFields(e *jx.Encoder) { +// encodeFields encodes fields. +func (s *R409) encodeFields(e *jx.Encoder) { { e.FieldStart("code") @@ -954,15 +2765,28 @@ func (s *R409) Decode(d *jx.Decoder) error { return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s *R409) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *R409) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. -func (s R500) Encode(e *jx.Encoder) { +func (s *R500) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s R500) encodeFields(e *jx.Encoder) { +// encodeFields encodes fields. +func (s *R500) encodeFields(e *jx.Encoder) { { e.FieldStart("code") @@ -1075,73 +2899,188 @@ func (s *R500) Decode(d *jx.Decoder) error { return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s *R500) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *R500) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. -func (s UpdateUsersReq) Encode(e *jx.Encoder) { +func (s *UpdateCardReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s UpdateUsersReq) encodeFields(e *jx.Encoder) { +// encodeFields encodes fields. +func (s *UpdateCardReq) encodeFields(e *jx.Encoder) { { - if s.Hp.Set { - e.FieldStart("hp") - s.Hp.Encode(e) + if s.Owner.Set { + e.FieldStart("owner") + s.Owner.Encode(e) + } + } +} + +var jsonFieldsNameOfUpdateCardReq = [1]string{ + 0: "owner", +} + +// Decode decodes UpdateCardReq from json. +func (s *UpdateCardReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UpdateCardReq to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + 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 UpdateCardReq") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UpdateCardReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UpdateCardReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UpdateGroupReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UpdateGroupReq) encodeFields(e *jx.Encoder) { + { + if s.Name.Set { + e.FieldStart("name") + s.Name.Encode(e) } } { - if s.Attack.Set { - e.FieldStart("attack") - s.Attack.Encode(e) + if s.Users != nil { + e.FieldStart("users") + e.ArrStart() + for _, elem := range s.Users { + e.Int(elem) + } + e.ArrEnd() } } - { - if s.Defense.Set { - e.FieldStart("defense") - s.Defense.Encode(e) - } +} + +var jsonFieldsNameOfUpdateGroupReq = [2]string{ + 0: "name", + 1: "users", +} + +// Decode decodes UpdateGroupReq from json. +func (s *UpdateGroupReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UpdateGroupReq to nil") } - { - if s.Critical.Set { - e.FieldStart("critical") - s.Critical.Encode(e) + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "name": + if err := func() error { + s.Name.Reset() + if err := s.Name.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "users": + if err := func() error { + s.Users = 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.Users = append(s.Users, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"users\"") + } + default: + return d.Skip() } + return nil + }); err != nil { + return errors.Wrap(err, "decode UpdateGroupReq") } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UpdateGroupReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UpdateGroupReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UpdateUserReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UpdateUserReq) encodeFields(e *jx.Encoder) { { - if s.Battle.Set { - e.FieldStart("battle") - s.Battle.Encode(e) - } - } - { - if s.Win.Set { - e.FieldStart("win") - s.Win.Encode(e) - } - } - { - if s.Day.Set { - e.FieldStart("day") - s.Day.Encode(e) - } - } - { - if s.Percentage.Set { - e.FieldStart("percentage") - s.Percentage.Encode(e) - } - } - { - if s.Limit.Set { - e.FieldStart("limit") - s.Limit.Encode(e) - } - } - { - if s.Comment.Set { - e.FieldStart("comment") - s.Comment.Encode(e) + if s.UpdatedAt.Set { + e.FieldStart("updated_at") + s.UpdatedAt.Encode(e, json.EncodeDateTime) } } { @@ -1151,135 +3090,40 @@ func (s UpdateUsersReq) encodeFields(e *jx.Encoder) { } } { - if s.UpdatedAt.Set { - e.FieldStart("updated_at") - s.UpdatedAt.Encode(e, json.EncodeDateTime) + if s.Card != nil { + e.FieldStart("card") + e.ArrStart() + for _, elem := range s.Card { + e.Int(elem) + } + e.ArrEnd() } } } -var jsonFieldsNameOfUpdateUsersReq = [12]string{ - 0: "hp", - 1: "attack", - 2: "defense", - 3: "critical", - 4: "battle", - 5: "win", - 6: "day", - 7: "percentage", - 8: "limit", - 9: "comment", - 10: "next", - 11: "updated_at", +var jsonFieldsNameOfUpdateUserReq = [3]string{ + 0: "updated_at", + 1: "next", + 2: "card", } -// Decode decodes UpdateUsersReq from json. -func (s *UpdateUsersReq) Decode(d *jx.Decoder) error { +// Decode decodes UpdateUserReq from json. +func (s *UpdateUserReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode UpdateUsersReq to nil") + return errors.New("invalid: unable to decode UpdateUserReq to nil") } if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "hp": + case "updated_at": if err := func() error { - s.Hp.Reset() - if err := s.Hp.Decode(d); err != nil { + 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 \"hp\"") - } - case "attack": - if err := func() error { - s.Attack.Reset() - if err := s.Attack.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"attack\"") - } - case "defense": - if err := func() error { - s.Defense.Reset() - if err := s.Defense.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"defense\"") - } - case "critical": - if err := func() error { - s.Critical.Reset() - if err := s.Critical.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"critical\"") - } - case "battle": - if err := func() error { - s.Battle.Reset() - if err := s.Battle.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"battle\"") - } - case "win": - if err := func() error { - s.Win.Reset() - if err := s.Win.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"win\"") - } - case "day": - if err := func() error { - s.Day.Reset() - if err := s.Day.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"day\"") - } - case "percentage": - if err := func() error { - s.Percentage.Reset() - if err := s.Percentage.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"percentage\"") - } - 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 "comment": - if err := func() error { - s.Comment.Reset() - if err := s.Comment.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"comment\"") + return errors.Wrap(err, "decode field \"updated_at\"") } case "next": if err := func() error { @@ -1291,110 +3135,67 @@ func (s *UpdateUsersReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"next\"") } - case "updated_at": + case "card": if err := func() error { - s.UpdatedAt.Reset() - if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil { + s.Card = 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.Card = append(s.Card, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"updated_at\"") + return errors.Wrap(err, "decode field \"card\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode UpdateUsersReq") + return errors.Wrap(err, "decode UpdateUserReq") } return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s *UpdateUserReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UpdateUserReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. -func (s UsersCreate) Encode(e *jx.Encoder) { +func (s *UserCardList) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s UsersCreate) encodeFields(e *jx.Encoder) { +// encodeFields encodes fields. +func (s *UserCardList) encodeFields(e *jx.Encoder) { { e.FieldStart("id") e.Int(s.ID) } { - - e.FieldStart("user") - e.Str(s.User) - } - { - if s.Chara.Set { - e.FieldStart("chara") - s.Chara.Encode(e) - } - } - { - if s.Skill.Set { - e.FieldStart("skill") - s.Skill.Encode(e) - } - } - { - if s.Hp.Set { - e.FieldStart("hp") - s.Hp.Encode(e) - } - } - { - if s.Attack.Set { - e.FieldStart("attack") - s.Attack.Encode(e) - } - } - { - if s.Defense.Set { - e.FieldStart("defense") - s.Defense.Encode(e) - } - } - { - if s.Critical.Set { - e.FieldStart("critical") - s.Critical.Encode(e) - } - } - { - if s.Battle.Set { - e.FieldStart("battle") - s.Battle.Encode(e) - } - } - { - if s.Win.Set { - e.FieldStart("win") - s.Win.Encode(e) - } - } - { - if s.Day.Set { - e.FieldStart("day") - s.Day.Encode(e) - } - } - { - if s.Percentage.Set { - e.FieldStart("percentage") - s.Percentage.Encode(e) - } - } - { - if s.Limit.Set { - e.FieldStart("limit") - s.Limit.Encode(e) + if s.Card.Set { + e.FieldStart("card") + s.Card.Encode(e) } } { @@ -1404,27 +3205,9 @@ func (s UsersCreate) encodeFields(e *jx.Encoder) { } } { - if s.Comment.Set { - e.FieldStart("comment") - s.Comment.Encode(e) - } - } - { - if s.CreatedAt.Set { - e.FieldStart("created_at") - s.CreatedAt.Encode(e, json.EncodeDateTime) - } - } - { - if s.Next.Set { - e.FieldStart("next") - s.Next.Encode(e) - } - } - { - if s.UpdatedAt.Set { - e.FieldStart("updated_at") - s.UpdatedAt.Encode(e, json.EncodeDateTime) + if s.Cp.Set { + e.FieldStart("cp") + s.Cp.Encode(e) } } { @@ -1433,36 +3216,29 @@ func (s UsersCreate) encodeFields(e *jx.Encoder) { s.URL.Encode(e) } } -} - -var jsonFieldsNameOfUsersCreate = [19]string{ - 0: "id", - 1: "user", - 2: "chara", - 3: "skill", - 4: "hp", - 5: "attack", - 6: "defense", - 7: "critical", - 8: "battle", - 9: "win", - 10: "day", - 11: "percentage", - 12: "limit", - 13: "status", - 14: "comment", - 15: "created_at", - 16: "next", - 17: "updated_at", - 18: "url", -} - -// Decode decodes UsersCreate from json. -func (s *UsersCreate) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode UsersCreate to nil") + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } } - var requiredBitSet [3]uint8 +} + +var jsonFieldsNameOfUserCardList = [6]string{ + 0: "id", + 1: "card", + 2: "status", + 3: "cp", + 4: "url", + 5: "created_at", +} + +// Decode decodes UserCardList from json. +func (s *UserCardList) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UserCardList to nil") + } + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -1478,127 +3254,15 @@ func (s *UsersCreate) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"id\"") } - case "user": - requiredBitSet[0] |= 1 << 1 + case "card": if err := func() error { - v, err := d.Str() - s.User = string(v) - if err != nil { + s.Card.Reset() + if err := s.Card.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"user\"") - } - case "chara": - if err := func() error { - s.Chara.Reset() - if err := s.Chara.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"chara\"") - } - case "skill": - if err := func() error { - s.Skill.Reset() - if err := s.Skill.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"skill\"") - } - case "hp": - if err := func() error { - s.Hp.Reset() - if err := s.Hp.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"hp\"") - } - case "attack": - if err := func() error { - s.Attack.Reset() - if err := s.Attack.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"attack\"") - } - case "defense": - if err := func() error { - s.Defense.Reset() - if err := s.Defense.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"defense\"") - } - case "critical": - if err := func() error { - s.Critical.Reset() - if err := s.Critical.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"critical\"") - } - case "battle": - if err := func() error { - s.Battle.Reset() - if err := s.Battle.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"battle\"") - } - case "win": - if err := func() error { - s.Win.Reset() - if err := s.Win.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"win\"") - } - case "day": - if err := func() error { - s.Day.Reset() - if err := s.Day.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"day\"") - } - case "percentage": - if err := func() error { - s.Percentage.Reset() - if err := s.Percentage.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"percentage\"") - } - 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\"") + return errors.Wrap(err, "decode field \"card\"") } case "status": if err := func() error { @@ -1610,45 +3274,15 @@ func (s *UsersCreate) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"status\"") } - case "comment": + case "cp": if err := func() error { - s.Comment.Reset() - if err := s.Comment.Decode(d); err != nil { + s.Cp.Reset() + if err := s.Cp.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"comment\"") - } - 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 "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 "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\"") + return errors.Wrap(err, "decode field \"cp\"") } case "url": if err := func() error { @@ -1660,19 +3294,27 @@ func (s *UsersCreate) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"url\"") } + 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 UsersCreate") + return errors.Wrap(err, "decode UserCardList") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [3]uint8{ - 0b00000011, - 0b00000000, - 0b00000000, + for i, mask := range [1]uint8{ + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -1684,8 +3326,8 @@ func (s *UsersCreate) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfUsersCreate) { - name = jsonFieldsNameOfUsersCreate[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfUserCardList) { + name = jsonFieldsNameOfUserCardList[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -1705,15 +3347,28 @@ func (s *UsersCreate) Decode(d *jx.Decoder) error { return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s *UserCardList) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserCardList) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. -func (s UsersList) Encode(e *jx.Encoder) { +func (s *UserCreate) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s UsersList) encodeFields(e *jx.Encoder) { +// encodeFields encodes fields. +func (s *UserCreate) encodeFields(e *jx.Encoder) { { e.FieldStart("id") @@ -1721,86 +3376,8 @@ func (s UsersList) encodeFields(e *jx.Encoder) { } { - e.FieldStart("user") - e.Str(s.User) - } - { - if s.Chara.Set { - e.FieldStart("chara") - s.Chara.Encode(e) - } - } - { - if s.Skill.Set { - e.FieldStart("skill") - s.Skill.Encode(e) - } - } - { - if s.Hp.Set { - e.FieldStart("hp") - s.Hp.Encode(e) - } - } - { - if s.Attack.Set { - e.FieldStart("attack") - s.Attack.Encode(e) - } - } - { - if s.Defense.Set { - e.FieldStart("defense") - s.Defense.Encode(e) - } - } - { - if s.Critical.Set { - e.FieldStart("critical") - s.Critical.Encode(e) - } - } - { - if s.Battle.Set { - e.FieldStart("battle") - s.Battle.Encode(e) - } - } - { - if s.Win.Set { - e.FieldStart("win") - s.Win.Encode(e) - } - } - { - if s.Day.Set { - e.FieldStart("day") - s.Day.Encode(e) - } - } - { - if s.Percentage.Set { - e.FieldStart("percentage") - s.Percentage.Encode(e) - } - } - { - if s.Limit.Set { - e.FieldStart("limit") - s.Limit.Encode(e) - } - } - { - if s.Status.Set { - e.FieldStart("status") - s.Status.Encode(e) - } - } - { - if s.Comment.Set { - e.FieldStart("comment") - s.Comment.Encode(e) - } + e.FieldStart("username") + e.Str(s.Username) } { if s.CreatedAt.Set { @@ -1808,12 +3385,6 @@ func (s UsersList) encodeFields(e *jx.Encoder) { s.CreatedAt.Encode(e, json.EncodeDateTime) } } - { - if s.Next.Set { - e.FieldStart("next") - s.Next.Encode(e) - } - } { if s.UpdatedAt.Set { e.FieldStart("updated_at") @@ -1821,41 +3392,27 @@ func (s UsersList) encodeFields(e *jx.Encoder) { } } { - if s.URL.Set { - e.FieldStart("url") - s.URL.Encode(e) + if s.Next.Set { + e.FieldStart("next") + s.Next.Encode(e) } } } -var jsonFieldsNameOfUsersList = [19]string{ - 0: "id", - 1: "user", - 2: "chara", - 3: "skill", - 4: "hp", - 5: "attack", - 6: "defense", - 7: "critical", - 8: "battle", - 9: "win", - 10: "day", - 11: "percentage", - 12: "limit", - 13: "status", - 14: "comment", - 15: "created_at", - 16: "next", - 17: "updated_at", - 18: "url", +var jsonFieldsNameOfUserCreate = [5]string{ + 0: "id", + 1: "username", + 2: "created_at", + 3: "updated_at", + 4: "next", } -// Decode decodes UsersList from json. -func (s *UsersList) Decode(d *jx.Decoder) error { +// Decode decodes UserCreate from json. +func (s *UserCreate) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode UsersList to nil") + return errors.New("invalid: unable to decode UserCreate to nil") } - var requiredBitSet [3]uint8 + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -1871,147 +3428,17 @@ func (s *UsersList) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"id\"") } - case "user": + case "username": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.User = string(v) + s.Username = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"user\"") - } - case "chara": - if err := func() error { - s.Chara.Reset() - if err := s.Chara.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"chara\"") - } - case "skill": - if err := func() error { - s.Skill.Reset() - if err := s.Skill.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"skill\"") - } - case "hp": - if err := func() error { - s.Hp.Reset() - if err := s.Hp.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"hp\"") - } - case "attack": - if err := func() error { - s.Attack.Reset() - if err := s.Attack.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"attack\"") - } - case "defense": - if err := func() error { - s.Defense.Reset() - if err := s.Defense.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"defense\"") - } - case "critical": - if err := func() error { - s.Critical.Reset() - if err := s.Critical.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"critical\"") - } - case "battle": - if err := func() error { - s.Battle.Reset() - if err := s.Battle.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"battle\"") - } - case "win": - if err := func() error { - s.Win.Reset() - if err := s.Win.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"win\"") - } - case "day": - if err := func() error { - s.Day.Reset() - if err := s.Day.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"day\"") - } - case "percentage": - if err := func() error { - s.Percentage.Reset() - if err := s.Percentage.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"percentage\"") - } - 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 "status": - if err := func() error { - s.Status.Reset() - if err := s.Status.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"status\"") - } - case "comment": - if err := func() error { - s.Comment.Reset() - if err := s.Comment.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"comment\"") + return errors.Wrap(err, "decode field \"username\"") } case "created_at": if err := func() error { @@ -2023,16 +3450,6 @@ func (s *UsersList) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"created_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 "updated_at": if err := func() error { s.UpdatedAt.Reset() @@ -2043,29 +3460,27 @@ func (s *UsersList) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } - case "url": + case "next": if err := func() error { - s.URL.Reset() - if err := s.URL.Decode(d); err != nil { + s.Next.Reset() + if err := s.Next.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"url\"") + return errors.Wrap(err, "decode field \"next\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode UsersList") + return errors.Wrap(err, "decode UserCreate") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [3]uint8{ + for i, mask := range [1]uint8{ 0b00000011, - 0b00000000, - 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -2077,8 +3492,8 @@ func (s *UsersList) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfUsersList) { - name = jsonFieldsNameOfUsersList[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfUserCreate) { + name = jsonFieldsNameOfUserCreate[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -2098,15 +3513,28 @@ func (s *UsersList) Decode(d *jx.Decoder) error { return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s *UserCreate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserCreate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. -func (s UsersRead) Encode(e *jx.Encoder) { +func (s *UserList) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s UsersRead) encodeFields(e *jx.Encoder) { +// encodeFields encodes fields. +func (s *UserList) encodeFields(e *jx.Encoder) { { e.FieldStart("id") @@ -2114,86 +3542,8 @@ func (s UsersRead) encodeFields(e *jx.Encoder) { } { - e.FieldStart("user") - e.Str(s.User) - } - { - if s.Chara.Set { - e.FieldStart("chara") - s.Chara.Encode(e) - } - } - { - if s.Skill.Set { - e.FieldStart("skill") - s.Skill.Encode(e) - } - } - { - if s.Hp.Set { - e.FieldStart("hp") - s.Hp.Encode(e) - } - } - { - if s.Attack.Set { - e.FieldStart("attack") - s.Attack.Encode(e) - } - } - { - if s.Defense.Set { - e.FieldStart("defense") - s.Defense.Encode(e) - } - } - { - if s.Critical.Set { - e.FieldStart("critical") - s.Critical.Encode(e) - } - } - { - if s.Battle.Set { - e.FieldStart("battle") - s.Battle.Encode(e) - } - } - { - if s.Win.Set { - e.FieldStart("win") - s.Win.Encode(e) - } - } - { - if s.Day.Set { - e.FieldStart("day") - s.Day.Encode(e) - } - } - { - if s.Percentage.Set { - e.FieldStart("percentage") - s.Percentage.Encode(e) - } - } - { - if s.Limit.Set { - e.FieldStart("limit") - s.Limit.Encode(e) - } - } - { - if s.Status.Set { - e.FieldStart("status") - s.Status.Encode(e) - } - } - { - if s.Comment.Set { - e.FieldStart("comment") - s.Comment.Encode(e) - } + e.FieldStart("username") + e.Str(s.Username) } { if s.CreatedAt.Set { @@ -2201,12 +3551,6 @@ func (s UsersRead) encodeFields(e *jx.Encoder) { s.CreatedAt.Encode(e, json.EncodeDateTime) } } - { - if s.Next.Set { - e.FieldStart("next") - s.Next.Encode(e) - } - } { if s.UpdatedAt.Set { e.FieldStart("updated_at") @@ -2214,41 +3558,27 @@ func (s UsersRead) encodeFields(e *jx.Encoder) { } } { - if s.URL.Set { - e.FieldStart("url") - s.URL.Encode(e) + if s.Next.Set { + e.FieldStart("next") + s.Next.Encode(e) } } } -var jsonFieldsNameOfUsersRead = [19]string{ - 0: "id", - 1: "user", - 2: "chara", - 3: "skill", - 4: "hp", - 5: "attack", - 6: "defense", - 7: "critical", - 8: "battle", - 9: "win", - 10: "day", - 11: "percentage", - 12: "limit", - 13: "status", - 14: "comment", - 15: "created_at", - 16: "next", - 17: "updated_at", - 18: "url", +var jsonFieldsNameOfUserList = [5]string{ + 0: "id", + 1: "username", + 2: "created_at", + 3: "updated_at", + 4: "next", } -// Decode decodes UsersRead from json. -func (s *UsersRead) Decode(d *jx.Decoder) error { +// Decode decodes UserList from json. +func (s *UserList) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode UsersRead to nil") + return errors.New("invalid: unable to decode UserList to nil") } - var requiredBitSet [3]uint8 + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -2264,147 +3594,17 @@ func (s *UsersRead) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"id\"") } - case "user": + case "username": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.User = string(v) + s.Username = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"user\"") - } - case "chara": - if err := func() error { - s.Chara.Reset() - if err := s.Chara.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"chara\"") - } - case "skill": - if err := func() error { - s.Skill.Reset() - if err := s.Skill.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"skill\"") - } - case "hp": - if err := func() error { - s.Hp.Reset() - if err := s.Hp.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"hp\"") - } - case "attack": - if err := func() error { - s.Attack.Reset() - if err := s.Attack.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"attack\"") - } - case "defense": - if err := func() error { - s.Defense.Reset() - if err := s.Defense.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"defense\"") - } - case "critical": - if err := func() error { - s.Critical.Reset() - if err := s.Critical.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"critical\"") - } - case "battle": - if err := func() error { - s.Battle.Reset() - if err := s.Battle.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"battle\"") - } - case "win": - if err := func() error { - s.Win.Reset() - if err := s.Win.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"win\"") - } - case "day": - if err := func() error { - s.Day.Reset() - if err := s.Day.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"day\"") - } - case "percentage": - if err := func() error { - s.Percentage.Reset() - if err := s.Percentage.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"percentage\"") - } - 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 "status": - if err := func() error { - s.Status.Reset() - if err := s.Status.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"status\"") - } - case "comment": - if err := func() error { - s.Comment.Reset() - if err := s.Comment.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"comment\"") + return errors.Wrap(err, "decode field \"username\"") } case "created_at": if err := func() error { @@ -2416,16 +3616,6 @@ func (s *UsersRead) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"created_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 "updated_at": if err := func() error { s.UpdatedAt.Reset() @@ -2436,29 +3626,27 @@ func (s *UsersRead) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } - case "url": + case "next": if err := func() error { - s.URL.Reset() - if err := s.URL.Decode(d); err != nil { + s.Next.Reset() + if err := s.Next.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"url\"") + return errors.Wrap(err, "decode field \"next\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode UsersRead") + return errors.Wrap(err, "decode UserList") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [3]uint8{ + for i, mask := range [1]uint8{ 0b00000011, - 0b00000000, - 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -2470,8 +3658,8 @@ func (s *UsersRead) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfUsersRead) { - name = jsonFieldsNameOfUsersRead[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfUserList) { + name = jsonFieldsNameOfUserList[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -2491,15 +3679,28 @@ func (s *UsersRead) Decode(d *jx.Decoder) error { return nil } +// MarshalJSON implements stdjson.Marshaler. +func (s *UserList) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserList) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. -func (s UsersUpdate) Encode(e *jx.Encoder) { +func (s *UserRead) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s UsersUpdate) encodeFields(e *jx.Encoder) { +// encodeFields encodes fields. +func (s *UserRead) encodeFields(e *jx.Encoder) { { e.FieldStart("id") @@ -2507,86 +3708,8 @@ func (s UsersUpdate) encodeFields(e *jx.Encoder) { } { - e.FieldStart("user") - e.Str(s.User) - } - { - if s.Chara.Set { - e.FieldStart("chara") - s.Chara.Encode(e) - } - } - { - if s.Skill.Set { - e.FieldStart("skill") - s.Skill.Encode(e) - } - } - { - if s.Hp.Set { - e.FieldStart("hp") - s.Hp.Encode(e) - } - } - { - if s.Attack.Set { - e.FieldStart("attack") - s.Attack.Encode(e) - } - } - { - if s.Defense.Set { - e.FieldStart("defense") - s.Defense.Encode(e) - } - } - { - if s.Critical.Set { - e.FieldStart("critical") - s.Critical.Encode(e) - } - } - { - if s.Battle.Set { - e.FieldStart("battle") - s.Battle.Encode(e) - } - } - { - if s.Win.Set { - e.FieldStart("win") - s.Win.Encode(e) - } - } - { - if s.Day.Set { - e.FieldStart("day") - s.Day.Encode(e) - } - } - { - if s.Percentage.Set { - e.FieldStart("percentage") - s.Percentage.Encode(e) - } - } - { - if s.Limit.Set { - e.FieldStart("limit") - s.Limit.Encode(e) - } - } - { - if s.Status.Set { - e.FieldStart("status") - s.Status.Encode(e) - } - } - { - if s.Comment.Set { - e.FieldStart("comment") - s.Comment.Encode(e) - } + e.FieldStart("username") + e.Str(s.Username) } { if s.CreatedAt.Set { @@ -2594,12 +3717,6 @@ func (s UsersUpdate) encodeFields(e *jx.Encoder) { s.CreatedAt.Encode(e, json.EncodeDateTime) } } - { - if s.Next.Set { - e.FieldStart("next") - s.Next.Encode(e) - } - } { if s.UpdatedAt.Set { e.FieldStart("updated_at") @@ -2607,41 +3724,27 @@ func (s UsersUpdate) encodeFields(e *jx.Encoder) { } } { - if s.URL.Set { - e.FieldStart("url") - s.URL.Encode(e) + if s.Next.Set { + e.FieldStart("next") + s.Next.Encode(e) } } } -var jsonFieldsNameOfUsersUpdate = [19]string{ - 0: "id", - 1: "user", - 2: "chara", - 3: "skill", - 4: "hp", - 5: "attack", - 6: "defense", - 7: "critical", - 8: "battle", - 9: "win", - 10: "day", - 11: "percentage", - 12: "limit", - 13: "status", - 14: "comment", - 15: "created_at", - 16: "next", - 17: "updated_at", - 18: "url", +var jsonFieldsNameOfUserRead = [5]string{ + 0: "id", + 1: "username", + 2: "created_at", + 3: "updated_at", + 4: "next", } -// Decode decodes UsersUpdate from json. -func (s *UsersUpdate) Decode(d *jx.Decoder) error { +// Decode decodes UserRead from json. +func (s *UserRead) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode UsersUpdate to nil") + return errors.New("invalid: unable to decode UserRead to nil") } - var requiredBitSet [3]uint8 + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -2657,147 +3760,17 @@ func (s *UsersUpdate) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"id\"") } - case "user": + case "username": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.User = string(v) + s.Username = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"user\"") - } - case "chara": - if err := func() error { - s.Chara.Reset() - if err := s.Chara.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"chara\"") - } - case "skill": - if err := func() error { - s.Skill.Reset() - if err := s.Skill.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"skill\"") - } - case "hp": - if err := func() error { - s.Hp.Reset() - if err := s.Hp.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"hp\"") - } - case "attack": - if err := func() error { - s.Attack.Reset() - if err := s.Attack.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"attack\"") - } - case "defense": - if err := func() error { - s.Defense.Reset() - if err := s.Defense.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"defense\"") - } - case "critical": - if err := func() error { - s.Critical.Reset() - if err := s.Critical.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"critical\"") - } - case "battle": - if err := func() error { - s.Battle.Reset() - if err := s.Battle.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"battle\"") - } - case "win": - if err := func() error { - s.Win.Reset() - if err := s.Win.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"win\"") - } - case "day": - if err := func() error { - s.Day.Reset() - if err := s.Day.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"day\"") - } - case "percentage": - if err := func() error { - s.Percentage.Reset() - if err := s.Percentage.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"percentage\"") - } - 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 "status": - if err := func() error { - s.Status.Reset() - if err := s.Status.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"status\"") - } - case "comment": - if err := func() error { - s.Comment.Reset() - if err := s.Comment.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"comment\"") + return errors.Wrap(err, "decode field \"username\"") } case "created_at": if err := func() error { @@ -2809,16 +3782,6 @@ func (s *UsersUpdate) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"created_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 "updated_at": if err := func() error { s.UpdatedAt.Reset() @@ -2829,29 +3792,27 @@ func (s *UsersUpdate) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } - case "url": + case "next": if err := func() error { - s.URL.Reset() - if err := s.URL.Decode(d); err != nil { + s.Next.Reset() + if err := s.Next.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"url\"") + return errors.Wrap(err, "decode field \"next\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode UsersUpdate") + return errors.Wrap(err, "decode UserRead") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [3]uint8{ + for i, mask := range [1]uint8{ 0b00000011, - 0b00000000, - 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -2863,8 +3824,8 @@ func (s *UsersUpdate) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfUsersUpdate) { - name = jsonFieldsNameOfUsersUpdate[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfUserRead) { + name = jsonFieldsNameOfUserRead[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -2883,3 +3844,182 @@ func (s *UsersUpdate) Decode(d *jx.Decoder) error { return nil } + +// MarshalJSON implements stdjson.Marshaler. +func (s *UserRead) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserRead) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UserUpdate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UserUpdate) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("username") + e.Str(s.Username) + } + { + 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.Next.Set { + e.FieldStart("next") + s.Next.Encode(e) + } + } +} + +var jsonFieldsNameOfUserUpdate = [5]string{ + 0: "id", + 1: "username", + 2: "created_at", + 3: "updated_at", + 4: "next", +} + +// Decode decodes UserUpdate from json. +func (s *UserUpdate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UserUpdate to nil") + } + var requiredBitSet [1]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 "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 "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\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UserUpdate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + 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(jsonFieldsNameOfUserUpdate) { + name = jsonFieldsNameOfUserUpdate[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 *UserUpdate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserUpdate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} diff --git a/ent/ogent/oas_middleware_gen.go b/ent/ogent/oas_middleware_gen.go new file mode 100644 index 0000000..3a7593f --- /dev/null +++ b/ent/ogent/oas_middleware_gen.go @@ -0,0 +1,10 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "github.com/ogen-go/ogen/middleware" +) + +// Middleware is middleware type. +type Middleware = middleware.Middleware diff --git a/ent/ogent/oas_param_dec_gen.go b/ent/ogent/oas_param_dec_gen.go deleted file mode 100644 index 9ed9615..0000000 --- a/ent/ogent/oas_param_dec_gen.go +++ /dev/null @@ -1,339 +0,0 @@ -// Code generated by ogen, DO NOT EDIT. - -package ogent - -import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" -) - -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) - -func decodeDeleteUsersParams(args [1]string, r *http.Request) (DeleteUsersParams, error) { - var ( - params DeleteUsersParams - ) - // Decode path: id. - { - param := args[0] - if len(param) > 0 { - d := uri.NewPathDecoder(uri.PathDecoderConfig{ - Param: "id", - Value: param, - Style: uri.PathStyleSimple, - Explode: false, - }) - - if err := func() error { - s, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToInt(s) - if err != nil { - return err - } - - params.ID = c - return nil - }(); err != nil { - return params, err - } - } else { - return params, errors.New("path: id: not specified") - } - } - return params, nil -} - -func decodeDrawDoneParams(args [1]string, r *http.Request) (DrawDoneParams, error) { - var ( - params DrawDoneParams - ) - // Decode path: id. - { - param := args[0] - if len(param) > 0 { - d := uri.NewPathDecoder(uri.PathDecoderConfig{ - Param: "id", - Value: param, - Style: uri.PathStyleSimple, - Explode: false, - }) - - if err := func() error { - s, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToInt(s) - if err != nil { - return err - } - - params.ID = c - return nil - }(); err != nil { - return params, err - } - } else { - return params, errors.New("path: id: not specified") - } - } - return params, nil -} - -func decodeDrawStartParams(args [1]string, r *http.Request) (DrawStartParams, error) { - var ( - params DrawStartParams - ) - // Decode path: id. - { - param := args[0] - if len(param) > 0 { - d := uri.NewPathDecoder(uri.PathDecoderConfig{ - Param: "id", - Value: param, - Style: uri.PathStyleSimple, - Explode: false, - }) - - if err := func() error { - s, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToInt(s) - if err != nil { - return err - } - - params.ID = c - return nil - }(); err != nil { - return params, err - } - } else { - return params, errors.New("path: id: not specified") - } - } - return params, nil -} - -func decodeListUsersParams(args [0]string, r *http.Request) (ListUsersParams, error) { - var ( - params ListUsersParams - queryArgs = r.URL.Query() - ) - // Decode query: page. - { - values, ok := queryArgs["page"] - if ok { - d := uri.NewQueryDecoder(uri.QueryDecoderConfig{ - Values: values, - Style: uri.QueryStyleForm, - Explode: true, - }) - - if err := func() error { - var paramsDotPageVal int - if err := func() error { - s, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToInt(s) - if err != nil { - return err - } - - paramsDotPageVal = c - return nil - }(); err != nil { - return err - } - params.Page.SetTo(paramsDotPageVal) - return nil - }(); err != nil { - return params, errors.Wrap(err, "query: page: parse") - } - } - } - // Decode query: itemsPerPage. - { - values, ok := queryArgs["itemsPerPage"] - if ok { - d := uri.NewQueryDecoder(uri.QueryDecoderConfig{ - Values: values, - Style: uri.QueryStyleForm, - Explode: true, - }) - - if err := func() error { - var paramsDotItemsPerPageVal int - if err := func() error { - s, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToInt(s) - if err != nil { - return err - } - - paramsDotItemsPerPageVal = c - return nil - }(); err != nil { - return err - } - params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal) - return nil - }(); err != nil { - return params, errors.Wrap(err, "query: itemsPerPage: parse") - } - } - } - return params, nil -} - -func decodeReadUsersParams(args [1]string, r *http.Request) (ReadUsersParams, error) { - var ( - params ReadUsersParams - ) - // Decode path: id. - { - param := args[0] - if len(param) > 0 { - d := uri.NewPathDecoder(uri.PathDecoderConfig{ - Param: "id", - Value: param, - Style: uri.PathStyleSimple, - Explode: false, - }) - - if err := func() error { - s, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToInt(s) - if err != nil { - return err - } - - params.ID = c - return nil - }(); err != nil { - return params, err - } - } else { - return params, errors.New("path: id: not specified") - } - } - return params, nil -} - -func decodeUpdateUsersParams(args [1]string, r *http.Request) (UpdateUsersParams, error) { - var ( - params UpdateUsersParams - ) - // Decode path: id. - { - param := args[0] - if len(param) > 0 { - d := uri.NewPathDecoder(uri.PathDecoderConfig{ - Param: "id", - Value: param, - Style: uri.PathStyleSimple, - Explode: false, - }) - - if err := func() error { - s, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToInt(s) - if err != nil { - return err - } - - params.ID = c - return nil - }(); err != nil { - return params, err - } - } else { - return params, errors.New("path: id: not specified") - } - } - return params, nil -} diff --git a/ent/ogent/oas_param_gen.go b/ent/ogent/oas_param_gen.go deleted file mode 100644 index 695142e..0000000 --- a/ent/ogent/oas_param_gen.go +++ /dev/null @@ -1,101 +0,0 @@ -// Code generated by ogen, DO NOT EDIT. - -package ogent - -import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" -) - -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) - -type DeleteUsersParams struct { - // ID of the Users. - ID int -} - -type DrawDoneParams struct { - ID int -} - -type DrawStartParams struct { - ID int -} - -type ListUsersParams struct { - // What page to render. - Page OptInt - // Item count to render per page. - ItemsPerPage OptInt -} - -type ReadUsersParams struct { - // ID of the Users. - ID int -} - -type UpdateUsersParams struct { - // ID of the Users. - ID int -} diff --git a/ent/ogent/oas_parameters_gen.go b/ent/ogent/oas_parameters_gen.go new file mode 100644 index 0000000..f7ceaa3 --- /dev/null +++ b/ent/ogent/oas_parameters_gen.go @@ -0,0 +1,1587 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "net/http" + "net/url" + + "github.com/go-faster/errors" + + "github.com/ogen-go/ogen/conv" + "github.com/ogen-go/ogen/middleware" + "github.com/ogen-go/ogen/ogenerrors" + "github.com/ogen-go/ogen/uri" + "github.com/ogen-go/ogen/validate" +) + +// DeleteCardParams is parameters of deleteCard operation. +type DeleteCardParams struct { + // ID of the Card. + ID int +} + +func unpackDeleteCardParams(packed middleware.Parameters) (params DeleteCardParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeDeleteCardParams(args [1]string, r *http.Request) (params DeleteCardParams, _ 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 +} + +// DeleteGroupParams is parameters of deleteGroup operation. +type DeleteGroupParams struct { + // ID of the Group. + ID int +} + +func unpackDeleteGroupParams(packed middleware.Parameters) (params DeleteGroupParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeDeleteGroupParams(args [1]string, r *http.Request) (params DeleteGroupParams, _ 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 +} + +// DeleteUserParams is parameters of deleteUser operation. +type DeleteUserParams struct { + // ID of the User. + ID int +} + +func unpackDeleteUserParams(packed middleware.Parameters) (params DeleteUserParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeDeleteUserParams(args [1]string, r *http.Request) (params DeleteUserParams, _ 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 +} + +// DrawDoneParams is parameters of drawDone operation. +type DrawDoneParams struct { + ID int +} + +func unpackDrawDoneParams(packed middleware.Parameters) (params DrawDoneParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeDrawDoneParams(args [1]string, r *http.Request) (params DrawDoneParams, _ 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 +} + +// DrawStartParams is parameters of drawStart operation. +type DrawStartParams struct { + ID int +} + +func unpackDrawStartParams(packed middleware.Parameters) (params DrawStartParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeDrawStartParams(args [1]string, r *http.Request) (params DrawStartParams, _ 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 +} + +// ListCardParams is parameters of listCard operation. +type ListCardParams struct { + // What page to render. + Page OptInt + // Item count to render per page. + ItemsPerPage OptInt +} + +func unpackListCardParams(packed middleware.Parameters) (params ListCardParams) { + { + 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 decodeListCardParams(args [0]string, r *http.Request) (params ListCardParams, _ 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: 255, + 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 +} + +// ListGroupParams is parameters of listGroup operation. +type ListGroupParams struct { + // What page to render. + Page OptInt + // Item count to render per page. + ItemsPerPage OptInt +} + +func unpackListGroupParams(packed middleware.Parameters) (params ListGroupParams) { + { + 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 decodeListGroupParams(args [0]string, r *http.Request) (params ListGroupParams, _ 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: 255, + 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 +} + +// ListGroupUsersParams is parameters of listGroupUsers operation. +type ListGroupUsersParams struct { + // ID of the Group. + ID int + // What page to render. + Page OptInt + // Item count to render per page. + ItemsPerPage OptInt +} + +func unpackListGroupUsersParams(packed middleware.Parameters) (params ListGroupUsersParams) { + { + 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 decodeListGroupUsersParams(args [1]string, r *http.Request) (params ListGroupUsersParams, _ 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 +} + +// ListUserParams is parameters of listUser operation. +type ListUserParams struct { + // What page to render. + Page OptInt + // Item count to render per page. + ItemsPerPage OptInt +} + +func unpackListUserParams(packed middleware.Parameters) (params ListUserParams) { + { + 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 decodeListUserParams(args [0]string, r *http.Request) (params ListUserParams, _ 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: 255, + 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 +} + +// ListUserCardParams is parameters of listUserCard operation. +type ListUserCardParams struct { + // ID of the User. + ID int + // What page to render. + Page OptInt + // Item count to render per page. + ItemsPerPage OptInt +} + +func unpackListUserCardParams(packed middleware.Parameters) (params ListUserCardParams) { + { + 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 decodeListUserCardParams(args [1]string, r *http.Request) (params ListUserCardParams, _ 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 +} + +// ReadCardParams is parameters of readCard operation. +type ReadCardParams struct { + // ID of the Card. + ID int +} + +func unpackReadCardParams(packed middleware.Parameters) (params ReadCardParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeReadCardParams(args [1]string, r *http.Request) (params ReadCardParams, _ 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 +} + +// ReadCardOwnerParams is parameters of readCardOwner operation. +type ReadCardOwnerParams struct { + // ID of the Card. + ID int +} + +func unpackReadCardOwnerParams(packed middleware.Parameters) (params ReadCardOwnerParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeReadCardOwnerParams(args [1]string, r *http.Request) (params ReadCardOwnerParams, _ 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 +} + +// ReadGroupParams is parameters of readGroup operation. +type ReadGroupParams struct { + // ID of the Group. + ID int +} + +func unpackReadGroupParams(packed middleware.Parameters) (params ReadGroupParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeReadGroupParams(args [1]string, r *http.Request) (params ReadGroupParams, _ 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 +} + +// ReadUserParams is parameters of readUser operation. +type ReadUserParams struct { + // ID of the User. + ID int +} + +func unpackReadUserParams(packed middleware.Parameters) (params ReadUserParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeReadUserParams(args [1]string, r *http.Request) (params ReadUserParams, _ 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 +} + +// UpdateCardParams is parameters of updateCard operation. +type UpdateCardParams struct { + // ID of the Card. + ID int +} + +func unpackUpdateCardParams(packed middleware.Parameters) (params UpdateCardParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeUpdateCardParams(args [1]string, r *http.Request) (params UpdateCardParams, _ 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 +} + +// UpdateGroupParams is parameters of updateGroup operation. +type UpdateGroupParams struct { + // ID of the Group. + ID int +} + +func unpackUpdateGroupParams(packed middleware.Parameters) (params UpdateGroupParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeUpdateGroupParams(args [1]string, r *http.Request) (params UpdateGroupParams, _ 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 +} + +// UpdateUserParams is parameters of updateUser operation. +type UpdateUserParams struct { + // ID of the User. + ID int +} + +func unpackUpdateUserParams(packed middleware.Parameters) (params UpdateUserParams) { + { + key := middleware.ParameterKey{ + Name: "id", + In: "path", + } + params.ID = packed[key].(int) + } + return params +} + +func decodeUpdateUserParams(args [1]string, r *http.Request) (params UpdateUserParams, _ 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 +} diff --git a/ent/ogent/oas_req_dec_gen.go b/ent/ogent/oas_req_dec_gen.go deleted file mode 100644 index 34fea94..0000000 --- a/ent/ogent/oas_req_dec_gen.go +++ /dev/null @@ -1,159 +0,0 @@ -// Code generated by ogen, DO NOT EDIT. - -package ogent - -import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" -) - -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) - -func decodeCreateUsersRequest(r *http.Request, span trace.Span) (req CreateUsersReq, err error) { - switch ct := r.Header.Get("Content-Type"); ct { - case "application/json": - if r.ContentLength == 0 { - return req, validate.ErrBodyRequired - } - - var request CreateUsersReq - buf := getBuf() - defer putBuf(buf) - written, err := io.Copy(buf, r.Body) - if err != nil { - return req, err - } - - if written == 0 { - return req, validate.ErrBodyRequired - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - if err := func() error { - if err := request.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return req, errors.Wrap(err, "decode CreateUsers:application/json request") - } - if err := func() error { - if err := request.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - return req, errors.Wrap(err, "validate CreateUsers request") - } - return request, nil - default: - return req, validate.InvalidContentType(ct) - } -} - -func decodeUpdateUsersRequest(r *http.Request, span trace.Span) (req UpdateUsersReq, err error) { - switch ct := r.Header.Get("Content-Type"); ct { - case "application/json": - if r.ContentLength == 0 { - return req, validate.ErrBodyRequired - } - - var request UpdateUsersReq - buf := getBuf() - defer putBuf(buf) - written, err := io.Copy(buf, r.Body) - if err != nil { - return req, err - } - - if written == 0 { - return req, validate.ErrBodyRequired - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - if err := func() error { - if err := request.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return req, errors.Wrap(err, "decode UpdateUsers:application/json request") - } - if err := func() error { - if err := request.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - return req, errors.Wrap(err, "validate UpdateUsers request") - } - return request, nil - default: - return req, validate.InvalidContentType(ct) - } -} diff --git a/ent/ogent/oas_req_enc_gen.go b/ent/ogent/oas_req_enc_gen.go deleted file mode 100644 index 62b8e62..0000000 --- a/ent/ogent/oas_req_enc_gen.go +++ /dev/null @@ -1,87 +0,0 @@ -// Code generated by ogen, DO NOT EDIT. - -package ogent - -import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" -) - -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) - -func encodeCreateUsersRequestJSON(req CreateUsersReq, span trace.Span) (data *jx.Encoder, err error) { - e := jx.GetEncoder() - - req.Encode(e) - - return e, nil -} - -func encodeUpdateUsersRequestJSON(req UpdateUsersReq, span trace.Span) (data *jx.Encoder, err error) { - e := jx.GetEncoder() - - req.Encode(e) - - return e, nil -} diff --git a/ent/ogent/oas_request_decoders_gen.go b/ent/ogent/oas_request_decoders_gen.go new file mode 100644 index 0000000..304ff41 --- /dev/null +++ b/ent/ogent/oas_request_decoders_gen.go @@ -0,0 +1,394 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "io" + "mime" + "net/http" + + "github.com/go-faster/errors" + "github.com/go-faster/jx" + "go.uber.org/multierr" + + "github.com/ogen-go/ogen/ogenerrors" + "github.com/ogen-go/ogen/validate" +) + +func (s *Server) decodeCreateCardRequest(r *http.Request) ( + req *CreateCardReq, + 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 CreateCardReq + 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) decodeCreateGroupRequest(r *http.Request) ( + req *CreateGroupReq, + 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 CreateGroupReq + 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) decodeCreateUserRequest(r *http.Request) ( + req *CreateUserReq, + 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 CreateUserReq + 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) decodeUpdateCardRequest(r *http.Request) ( + req *UpdateCardReq, + 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 UpdateCardReq + 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) decodeUpdateGroupRequest(r *http.Request) ( + req *UpdateGroupReq, + 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 UpdateGroupReq + 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) decodeUpdateUserRequest(r *http.Request) ( + req *UpdateUserReq, + 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 UpdateUserReq + 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) + } +} diff --git a/ent/ogent/oas_request_encoders_gen.go b/ent/ogent/oas_request_encoders_gen.go new file mode 100644 index 0000000..74cd1d0 --- /dev/null +++ b/ent/ogent/oas_request_encoders_gen.go @@ -0,0 +1,96 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "bytes" + "net/http" + + "github.com/go-faster/jx" + + ht "github.com/ogen-go/ogen/http" +) + +func encodeCreateCardRequest( + req *CreateCardReq, + 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 encodeCreateGroupRequest( + req *CreateGroupReq, + 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 encodeCreateUserRequest( + req *CreateUserReq, + 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 encodeUpdateCardRequest( + req *UpdateCardReq, + 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 encodeUpdateGroupRequest( + req *UpdateGroupReq, + 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 encodeUpdateUserRequest( + req *UpdateUserReq, + 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 +} diff --git a/ent/ogent/oas_res_dec_gen.go b/ent/ogent/oas_res_dec_gen.go deleted file mode 100644 index b1fe3c1..0000000 --- a/ent/ogent/oas_res_dec_gen.go +++ /dev/null @@ -1,747 +0,0 @@ -// Code generated by ogen, DO NOT EDIT. - -package ogent - -import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" -) - -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) - -func decodeCreateUsersResponse(resp *http.Response, span trace.Span) (res CreateUsersRes, err error) { - switch resp.StatusCode { - case 200: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response UsersCreate - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 400: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R400 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 409: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R409 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 500: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R500 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - default: - return res, validate.UnexpectedStatusCode(resp.StatusCode) - } -} - -func decodeDeleteUsersResponse(resp *http.Response, span trace.Span) (res DeleteUsersRes, err error) { - switch resp.StatusCode { - case 204: - return &DeleteUsersNoContent{}, nil - case 400: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R400 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 404: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R404 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 409: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R409 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 500: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R500 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - default: - return res, validate.UnexpectedStatusCode(resp.StatusCode) - } -} - -func decodeDrawDoneResponse(resp *http.Response, span trace.Span) (res DrawDoneNoContent, err error) { - switch resp.StatusCode { - case 204: - return DrawDoneNoContent{}, nil - default: - return res, validate.UnexpectedStatusCode(resp.StatusCode) - } -} - -func decodeDrawStartResponse(resp *http.Response, span trace.Span) (res DrawStartNoContent, err error) { - switch resp.StatusCode { - case 204: - return DrawStartNoContent{}, nil - default: - return res, validate.UnexpectedStatusCode(resp.StatusCode) - } -} - -func decodeListUsersResponse(resp *http.Response, span trace.Span) (res ListUsersRes, err error) { - switch resp.StatusCode { - case 200: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response ListUsersOKApplicationJSON - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 400: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R400 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 404: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R404 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 409: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R409 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 500: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R500 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - default: - return res, validate.UnexpectedStatusCode(resp.StatusCode) - } -} - -func decodeReadUsersResponse(resp *http.Response, span trace.Span) (res ReadUsersRes, err error) { - switch resp.StatusCode { - case 200: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response UsersRead - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 400: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R400 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 404: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R404 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 409: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R409 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 500: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R500 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - default: - return res, validate.UnexpectedStatusCode(resp.StatusCode) - } -} - -func decodeUpdateUsersResponse(resp *http.Response, span trace.Span) (res UpdateUsersRes, err error) { - switch resp.StatusCode { - case 200: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response UsersUpdate - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 400: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R400 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 404: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R404 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 409: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R409 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - case 500: - switch ct := resp.Header.Get("Content-Type"); ct { - case "application/json": - buf := getBuf() - defer putBuf(buf) - if _, err := io.Copy(buf, resp.Body); err != nil { - return res, err - } - - d := jx.GetDecoder() - defer jx.PutDecoder(d) - d.ResetBytes(buf.Bytes()) - - var response R500 - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return res, err - } - - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - default: - return res, validate.UnexpectedStatusCode(resp.StatusCode) - } -} diff --git a/ent/ogent/oas_res_enc_gen.go b/ent/ogent/oas_res_enc_gen.go deleted file mode 100644 index 528f774..0000000 --- a/ent/ogent/oas_res_enc_gen.go +++ /dev/null @@ -1,395 +0,0 @@ -// Code generated by ogen, DO NOT EDIT. - -package ogent - -import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" -) - -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) - -func encodeCreateUsersResponse(response CreateUsersRes, w http.ResponseWriter, span trace.Span) error { - switch response := response.(type) { - case *UsersCreate: - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(200) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - response.Encode(e) - if _, err := e.WriteTo(w); err != nil { - return errors.Wrap(err, "write") - } - - return nil - default: - return errors.Errorf("/users"+`: unexpected response type: %T`, response) - } -} - -func encodeDeleteUsersResponse(response DeleteUsersRes, w http.ResponseWriter, span trace.Span) error { - switch response := response.(type) { - case *DeleteUsersNoContent: - w.WriteHeader(204) - return nil - case *R400: - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(400) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - response.Encode(e) - if _, err := e.WriteTo(w); err != nil { - return errors.Wrap(err, "write") - } - - return nil - default: - return errors.Errorf("/users/{id}"+`: unexpected response type: %T`, response) - } -} - -func encodeDrawDoneResponse(response DrawDoneNoContent, w http.ResponseWriter, span trace.Span) error { - w.WriteHeader(204) - return nil -} - -func encodeDrawStartResponse(response DrawStartNoContent, w http.ResponseWriter, span trace.Span) error { - w.WriteHeader(204) - return nil -} - -func encodeListUsersResponse(response ListUsersRes, w http.ResponseWriter, span trace.Span) error { - switch response := response.(type) { - case *ListUsersOKApplicationJSON: - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(200) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - response.Encode(e) - if _, err := e.WriteTo(w); err != nil { - return errors.Wrap(err, "write") - } - - return nil - default: - return errors.Errorf("/users"+`: unexpected response type: %T`, response) - } -} - -func encodeReadUsersResponse(response ReadUsersRes, w http.ResponseWriter, span trace.Span) error { - switch response := response.(type) { - case *UsersRead: - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(200) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - response.Encode(e) - if _, err := e.WriteTo(w); err != nil { - return errors.Wrap(err, "write") - } - - return nil - default: - return errors.Errorf("/users/{id}"+`: unexpected response type: %T`, response) - } -} - -func encodeUpdateUsersResponse(response UpdateUsersRes, w http.ResponseWriter, span trace.Span) error { - switch response := response.(type) { - case *UsersUpdate: - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(200) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - 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) - e := jx.GetEncoder() - defer jx.PutEncoder(e) - - response.Encode(e) - if _, err := e.WriteTo(w); err != nil { - return errors.Wrap(err, "write") - } - - return nil - default: - return errors.Errorf("/users/{id}"+`: unexpected response type: %T`, response) - } -} diff --git a/ent/ogent/oas_response_decoders_gen.go b/ent/ogent/oas_response_decoders_gen.go new file mode 100644 index 0000000..9db0016 --- /dev/null +++ b/ent/ogent/oas_response_decoders_gen.go @@ -0,0 +1,3090 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "io" + "mime" + "net/http" + + "github.com/go-faster/errors" + "github.com/go-faster/jx" + + "github.com/ogen-go/ogen/ogenerrors" + "github.com/ogen-go/ogen/validate" +) + +func decodeCreateCardResponse(resp *http.Response) (res CreateCardRes, 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 CardCreate + 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 decodeCreateGroupResponse(resp *http.Response) (res CreateGroupRes, 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 GroupCreate + 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 decodeCreateUserResponse(resp *http.Response) (res CreateUserRes, 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 UserCreate + 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 decodeDeleteCardResponse(resp *http.Response) (res DeleteCardRes, err error) { + switch resp.StatusCode { + case 204: + // Code 204. + return &DeleteCardNoContent{}, 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 decodeDeleteGroupResponse(resp *http.Response) (res DeleteGroupRes, err error) { + switch resp.StatusCode { + case 204: + // Code 204. + return &DeleteGroupNoContent{}, 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 decodeDeleteUserResponse(resp *http.Response) (res DeleteUserRes, err error) { + switch resp.StatusCode { + case 204: + // Code 204. + return &DeleteUserNoContent{}, 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 decodeDrawDoneResponse(resp *http.Response) (res *DrawDoneNoContent, err error) { + switch resp.StatusCode { + case 204: + // Code 204. + return &DrawDoneNoContent{}, nil + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeDrawStartResponse(resp *http.Response) (res *DrawStartNoContent, err error) { + switch resp.StatusCode { + case 204: + // Code 204. + return &DrawStartNoContent{}, nil + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeListCardResponse(resp *http.Response) (res ListCardRes, 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 ListCardOKApplicationJSON + 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 decodeListGroupResponse(resp *http.Response) (res ListGroupRes, 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 ListGroupOKApplicationJSON + 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 decodeListGroupUsersResponse(resp *http.Response) (res ListGroupUsersRes, 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 ListGroupUsersOKApplicationJSON + 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 decodeListUserResponse(resp *http.Response) (res ListUserRes, 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 ListUserOKApplicationJSON + 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 decodeListUserCardResponse(resp *http.Response) (res ListUserCardRes, 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 ListUserCardOKApplicationJSON + 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 decodeReadCardResponse(resp *http.Response) (res ReadCardRes, 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 CardRead + 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 decodeReadCardOwnerResponse(resp *http.Response) (res ReadCardOwnerRes, 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 CardOwnerRead + 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 decodeReadGroupResponse(resp *http.Response) (res ReadGroupRes, 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 GroupRead + 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 decodeReadUserResponse(resp *http.Response) (res ReadUserRes, 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 UserRead + 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 decodeUpdateCardResponse(resp *http.Response) (res UpdateCardRes, 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 CardUpdate + 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 decodeUpdateGroupResponse(resp *http.Response) (res UpdateGroupRes, 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 GroupUpdate + 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 decodeUpdateUserResponse(resp *http.Response) (res UpdateUserRes, 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 UserUpdate + 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) +} diff --git a/ent/ogent/oas_response_encoders_gen.go b/ent/ogent/oas_response_encoders_gen.go new file mode 100644 index 0000000..96d462b --- /dev/null +++ b/ent/ogent/oas_response_encoders_gen.go @@ -0,0 +1,1178 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "net/http" + + "github.com/go-faster/errors" + "github.com/go-faster/jx" + "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/trace" +) + +func encodeCreateCardResponse(response CreateCardRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *CardCreate: + 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 encodeCreateGroupResponse(response CreateGroupRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *GroupCreate: + 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 encodeCreateUserResponse(response CreateUserRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *UserCreate: + 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 encodeDeleteCardResponse(response DeleteCardRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *DeleteCardNoContent: + 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 encodeDeleteGroupResponse(response DeleteGroupRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *DeleteGroupNoContent: + 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 encodeDeleteUserResponse(response DeleteUserRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *DeleteUserNoContent: + 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 encodeDrawDoneResponse(response *DrawDoneNoContent, w http.ResponseWriter, span trace.Span) error { + w.WriteHeader(204) + span.SetStatus(codes.Ok, http.StatusText(204)) + + return nil +} + +func encodeDrawStartResponse(response *DrawStartNoContent, w http.ResponseWriter, span trace.Span) error { + w.WriteHeader(204) + span.SetStatus(codes.Ok, http.StatusText(204)) + + return nil +} + +func encodeListCardResponse(response ListCardRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *ListCardOKApplicationJSON: + 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 encodeListGroupResponse(response ListGroupRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *ListGroupOKApplicationJSON: + 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 encodeListGroupUsersResponse(response ListGroupUsersRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *ListGroupUsersOKApplicationJSON: + 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 encodeListUserResponse(response ListUserRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *ListUserOKApplicationJSON: + 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 encodeListUserCardResponse(response ListUserCardRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *ListUserCardOKApplicationJSON: + 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 encodeReadCardResponse(response ReadCardRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *CardRead: + 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 encodeReadCardOwnerResponse(response ReadCardOwnerRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *CardOwnerRead: + 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 encodeReadGroupResponse(response ReadGroupRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *GroupRead: + 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 encodeReadUserResponse(response ReadUserRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *UserRead: + 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 encodeUpdateCardResponse(response UpdateCardRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *CardUpdate: + 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 encodeUpdateGroupResponse(response UpdateGroupRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *GroupUpdate: + 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 encodeUpdateUserResponse(response UpdateUserRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *UserUpdate: + 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) + } +} diff --git a/ent/ogent/oas_router_gen.go b/ent/ogent/oas_router_gen.go index 8ab74ec..d5dbaf7 100644 --- a/ent/ogent/oas_router_gen.go +++ b/ent/ogent/oas_router_gen.go @@ -3,259 +3,346 @@ package ogent import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" "net/http" "net/url" - "regexp" - "sort" - "strconv" "strings" - "sync" - "time" - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" ) -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) - -func (s *Server) notFound(w http.ResponseWriter, r *http.Request) { - s.cfg.NotFound(w, r) -} - // ServeHTTP serves http request as defined by OpenAPI v3 specification, // calling handler that matches the path or returning not found error. func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { elem := r.URL.Path + if rawPath := r.URL.RawPath; rawPath != "" { + if normalized, ok := uri.NormalizeEscapedPath(rawPath); ok { + elem = normalized + } + } + if prefix := s.cfg.Prefix; len(prefix) > 0 { + if strings.HasPrefix(elem, prefix) { + // Cut prefix from the path. + elem = strings.TrimPrefix(elem, prefix) + } else { + // Prefix doesn't match. + s.notFound(w, r) + return + } + } if len(elem) == 0 { s.notFound(w, r) return } args := [1]string{} + // Static code generated router with unwrapped path search. - switch r.Method { - case "DELETE": + switch { + default: if len(elem) == 0 { break } switch elem[0] { - case '/': // Prefix: "/users/" - if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" { - elem = elem[l:] - } else { - break - } - - // Param: "id" - // Leaf parameter - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf: DeleteUsers - s.handleDeleteUsersRequest([1]string{ - args[0], - }, w, r) - - return - } - } - case "GET": - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/users" - if l := len("/users"); len(elem) >= l && elem[0:l] == "/users" { + case '/': // Prefix: "/" + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - s.handleListUsersRequest([0]string{}, w, r) - - return + break } switch elem[0] { - case '/': // Prefix: "/" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { - elem = elem[l:] - } else { - break - } - - // Param: "id" - // Leaf parameter - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf: ReadUsers - s.handleReadUsersRequest([1]string{ - args[0], - }, w, r) - - return - } - } - } - case "PATCH": - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/users/" - if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" { - 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 { - s.handleUpdateUsersRequest([1]string{ - args[0], - }, w, r) - - return - } - switch elem[0] { - case '/': // Prefix: "/start" - if l := len("/start"); len(elem) >= l && elem[0:l] == "/start" { + case 'c': // Prefix: "cards" + if l := len("cards"); len(elem) >= l && elem[0:l] == "cards" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf: DrawStart - s.handleDrawStartRequest([1]string{ - args[0], - }, w, r) + switch r.Method { + case "GET": + s.handleListCardRequest([0]string{}, w, r) + case "POST": + s.handleCreateCardRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "GET,POST") + } return } - } - } - case "POST": - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/users" - if l := len("/users"); len(elem) >= l && elem[0:l] == "/users" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '/': // Prefix: "/" + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf: CreateUsers - s.handleCreateUsersRequest([0]string{}, w, r) + // Param: "id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] - return - } - } - case "PUT": - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/users/" - if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "DELETE": + s.handleDeleteCardRequest([1]string{ + args[0], + }, w, r) + case "GET": + s.handleReadCardRequest([1]string{ + args[0], + }, w, r) + case "PATCH": + s.handleUpdateCardRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "DELETE,GET,PATCH") + } - // Param: "id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + return + } + switch elem[0] { + case '/': // Prefix: "/" + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/d" - if l := len("/d"); len(elem) >= l && elem[0:l] == "/d" { + if len(elem) == 0 { + break + } + switch elem[0] { + case 'd': // Prefix: "d" + if l := len("d"); len(elem) >= l && elem[0:l] == "d" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "PUT": + s.handleDrawDoneRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "PUT") + } + + return + } + case 'o': // 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.handleReadCardOwnerRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "GET") + } + + return + } + } + } + } + case 'g': // Prefix: "groups" + if l := len("groups"); len(elem) >= l && elem[0:l] == "groups" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf: DrawDone - s.handleDrawDoneRequest([1]string{ - args[0], - }, w, r) + switch r.Method { + case "GET": + s.handleListGroupRequest([0]string{}, w, r) + case "POST": + s.handleCreateGroupRequest([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.handleDeleteGroupRequest([1]string{ + args[0], + }, w, r) + case "GET": + s.handleReadGroupRequest([1]string{ + args[0], + }, w, r) + case "PATCH": + s.handleUpdateGroupRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "DELETE,GET,PATCH") + } + + return + } + switch elem[0] { + case '/': // Prefix: "/users" + if l := len("/users"); len(elem) >= l && elem[0:l] == "/users" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleListGroupUsersRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "GET") + } + + return + } + } + } + case 'u': // Prefix: "users" + if l := len("users"); len(elem) >= l && elem[0:l] == "users" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleListUserRequest([0]string{}, w, r) + case "POST": + s.handleCreateUserRequest([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.handleDeleteUserRequest([1]string{ + args[0], + }, w, r) + case "GET": + s.handleReadUserRequest([1]string{ + args[0], + }, w, r) + case "PATCH": + s.handleUpdateUserRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "DELETE,GET,PATCH") + } + + return + } + switch elem[0] { + case '/': // Prefix: "/card" + if l := len("/card"); len(elem) >= l && elem[0:l] == "/card" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleListUserCardRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "GET") + } + + return + } + switch elem[0] { + case '/': // Prefix: "/start" + if l := len("/start"); len(elem) >= l && elem[0:l] == "/start" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "PATCH": + s.handleDrawStartRequest([1]string{ + args[0], + }, w, r) + default: + s.notAllowed(w, r, "PATCH") + } + + return + } + } + } + } } } } @@ -264,14 +351,28 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Route is route object. type Route struct { - name string - count int - args [1]string + name string + operationID string + pathPattern string + count int + args [1]string +} + +// Name returns ogen operation name. +// +// It is guaranteed to be unique and not empty. +func (r Route) Name() string { + return r.name } // OperationID returns OpenAPI operationId. func (r Route) OperationID() string { - return r.name + return r.operationID +} + +// PathPattern returns OpenAPI path. +func (r Route) PathPattern() string { + return r.pathPattern } // Args returns parsed arguments. @@ -280,185 +381,388 @@ func (r Route) Args() []string { } // FindRoute finds Route for given method and path. -func (s *Server) FindRoute(method, path string) (r Route, _ bool) { +// +// Note: this method does not unescape path or handle reserved characters in path properly. Use FindPath instead. +func (s *Server) FindRoute(method, path string) (Route, bool) { + return s.FindPath(method, &url.URL{Path: path}) +} + +// FindPath finds Route for given method and URL. +func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { var ( - args = [1]string{} - elem = path + elem = u.Path + args = r.args ) - r.args = args - if elem == "" { - return r, false + if rawPath := u.RawPath; rawPath != "" { + if normalized, ok := uri.NormalizeEscapedPath(rawPath); ok { + elem = normalized + } + defer func() { + for i, arg := range r.args[:r.count] { + if unescaped, err := url.PathUnescape(arg); err == nil { + r.args[i] = unescaped + } + } + }() } // Static code generated router with unwrapped path search. - switch method { - case "DELETE": + switch { + default: if len(elem) == 0 { break } switch elem[0] { - case '/': // Prefix: "/users/" - if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" { - elem = elem[l:] - } else { - break - } - - // Param: "id" - // Leaf parameter - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf: DeleteUsers - r.name = "DeleteUsers" - r.args = args - r.count = 1 - return r, true - } - } - case "GET": - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/users" - if l := len("/users"); len(elem) >= l && elem[0:l] == "/users" { + case '/': // Prefix: "/" + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - r.name = "ListUsers" - r.args = args - r.count = 0 - return r, true + break } switch elem[0] { - case '/': // Prefix: "/" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { - elem = elem[l:] - } else { - break - } - - // Param: "id" - // Leaf parameter - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf: ReadUsers - r.name = "ReadUsers" - r.args = args - r.count = 1 - return r, true - } - } - } - case "PATCH": - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/users/" - if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" { - 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 { - r.name = "UpdateUsers" - r.args = args - r.count = 1 - return r, true - } - switch elem[0] { - case '/': // Prefix: "/start" - if l := len("/start"); len(elem) >= l && elem[0:l] == "/start" { + case 'c': // Prefix: "cards" + if l := len("cards"); len(elem) >= l && elem[0:l] == "cards" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf: DrawStart - r.name = "DrawStart" - r.args = args - r.count = 1 - return r, true + switch method { + case "GET": + r.name = "ListCard" + r.operationID = "listCard" + r.pathPattern = "/cards" + r.args = args + r.count = 0 + return r, true + case "POST": + r.name = "CreateCard" + r.operationID = "createCard" + r.pathPattern = "/cards" + r.args = args + r.count = 0 + return r, true + default: + return + } } - } - } - case "POST": - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/users" - if l := len("/users"); len(elem) >= l && elem[0:l] == "/users" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '/': // Prefix: "/" + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf: CreateUsers - r.name = "CreateUsers" - r.args = args - r.count = 0 - return r, true - } - } - case "PUT": - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/users/" - if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" { - 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:] - // 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 = "DeleteCard" + r.operationID = "deleteCard" + r.pathPattern = "/cards/{id}" + r.args = args + r.count = 1 + return r, true + case "GET": + r.name = "ReadCard" + r.operationID = "readCard" + r.pathPattern = "/cards/{id}" + r.args = args + r.count = 1 + return r, true + case "PATCH": + r.name = "UpdateCard" + r.operationID = "updateCard" + r.pathPattern = "/cards/{id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/" + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/d" - if l := len("/d"); len(elem) >= l && elem[0:l] == "/d" { + if len(elem) == 0 { + break + } + switch elem[0] { + case 'd': // Prefix: "d" + if l := len("d"); len(elem) >= l && elem[0:l] == "d" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "PUT": + // Leaf: DrawDone + r.name = "DrawDone" + r.operationID = "drawDone" + r.pathPattern = "/cards/{id}/d" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + case 'o': // 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: ReadCardOwner + r.name = "ReadCardOwner" + r.operationID = "readCardOwner" + r.pathPattern = "/cards/{id}/owner" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + } + } + } + case 'g': // Prefix: "groups" + if l := len("groups"); len(elem) >= l && elem[0:l] == "groups" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf: DrawDone - r.name = "DrawDone" - r.args = args - r.count = 1 - return r, true + switch method { + case "GET": + r.name = "ListGroup" + r.operationID = "listGroup" + r.pathPattern = "/groups" + r.args = args + r.count = 0 + return r, true + case "POST": + r.name = "CreateGroup" + r.operationID = "createGroup" + r.pathPattern = "/groups" + 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 = "DeleteGroup" + r.operationID = "deleteGroup" + r.pathPattern = "/groups/{id}" + r.args = args + r.count = 1 + return r, true + case "GET": + r.name = "ReadGroup" + r.operationID = "readGroup" + r.pathPattern = "/groups/{id}" + r.args = args + r.count = 1 + return r, true + case "PATCH": + r.name = "UpdateGroup" + r.operationID = "updateGroup" + r.pathPattern = "/groups/{id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/users" + if l := len("/users"); len(elem) >= l && elem[0:l] == "/users" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "GET": + // Leaf: ListGroupUsers + r.name = "ListGroupUsers" + r.operationID = "listGroupUsers" + r.pathPattern = "/groups/{id}/users" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + } + } + case 'u': // Prefix: "users" + if l := len("users"); len(elem) >= l && elem[0:l] == "users" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "GET": + r.name = "ListUser" + r.operationID = "listUser" + r.pathPattern = "/users" + r.args = args + r.count = 0 + return r, true + case "POST": + r.name = "CreateUser" + r.operationID = "createUser" + r.pathPattern = "/users" + 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 = "DeleteUser" + r.operationID = "deleteUser" + r.pathPattern = "/users/{id}" + r.args = args + r.count = 1 + return r, true + case "GET": + r.name = "ReadUser" + r.operationID = "readUser" + r.pathPattern = "/users/{id}" + r.args = args + r.count = 1 + return r, true + case "PATCH": + r.name = "UpdateUser" + r.operationID = "updateUser" + r.pathPattern = "/users/{id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/card" + if l := len("/card"); len(elem) >= l && elem[0:l] == "/card" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "GET": + r.name = "ListUserCard" + r.operationID = "listUserCard" + r.pathPattern = "/users/{id}/card" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/start" + if l := len("/start"); len(elem) >= l && elem[0:l] == "/start" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "PATCH": + // Leaf: DrawStart + r.name = "DrawStart" + r.operationID = "drawStart" + r.pathPattern = "/users/{id}/card/start" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + } + } } } } diff --git a/ent/ogent/oas_schemas_gen.go b/ent/ogent/oas_schemas_gen.go index 008eeb5..748c29f 100644 --- a/ent/ogent/oas_schemas_gen.go +++ b/ent/ogent/oas_schemas_gen.go @@ -3,98 +3,524 @@ package ogent import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" "time" - "github.com/go-faster/errors" "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" ) -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) - -type CreateUsersReq struct { - User string "json:\"user\"" - Chara OptString "json:\"chara\"" - Skill OptInt "json:\"skill\"" - Hp OptInt "json:\"hp\"" - Attack OptInt "json:\"attack\"" - Defense OptInt "json:\"defense\"" - Critical OptInt "json:\"critical\"" - Battle OptInt "json:\"battle\"" - Win OptInt "json:\"win\"" - Day OptInt "json:\"day\"" - Percentage OptFloat64 "json:\"percentage\"" - Limit OptBool "json:\"limit\"" - Status OptString "json:\"status\"" - Comment OptString "json:\"comment\"" - CreatedAt OptDateTime "json:\"created_at\"" - Next OptString "json:\"next\"" - UpdatedAt OptDateTime "json:\"updated_at\"" - URL OptString "json:\"url\"" +// Ref: #/components/schemas/CardCreate +type CardCreate struct { + ID int `json:"id"` + Card OptInt `json:"card"` + Status OptString `json:"status"` + Cp OptInt `json:"cp"` + URL OptString `json:"url"` + CreatedAt OptDateTime `json:"created_at"` } -// DeleteUsersNoContent is response for DeleteUsers operation. -type DeleteUsersNoContent struct{} +// GetID returns the value of ID. +func (s *CardCreate) GetID() int { + return s.ID +} -func (*DeleteUsersNoContent) deleteUsersRes() {} +// GetCard returns the value of Card. +func (s *CardCreate) GetCard() OptInt { + return s.Card +} + +// GetStatus returns the value of Status. +func (s *CardCreate) GetStatus() OptString { + return s.Status +} + +// GetCp returns the value of Cp. +func (s *CardCreate) GetCp() OptInt { + return s.Cp +} + +// GetURL returns the value of URL. +func (s *CardCreate) GetURL() OptString { + return s.URL +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *CardCreate) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *CardCreate) SetID(val int) { + s.ID = val +} + +// SetCard sets the value of Card. +func (s *CardCreate) SetCard(val OptInt) { + s.Card = val +} + +// SetStatus sets the value of Status. +func (s *CardCreate) SetStatus(val OptString) { + s.Status = val +} + +// SetCp sets the value of Cp. +func (s *CardCreate) SetCp(val OptInt) { + s.Cp = val +} + +// SetURL sets the value of URL. +func (s *CardCreate) SetURL(val OptString) { + s.URL = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *CardCreate) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +func (*CardCreate) createCardRes() {} + +// Ref: #/components/schemas/CardList +type CardList struct { + ID int `json:"id"` + Card OptInt `json:"card"` + Status OptString `json:"status"` + Cp OptInt `json:"cp"` + URL OptString `json:"url"` + CreatedAt OptDateTime `json:"created_at"` +} + +// GetID returns the value of ID. +func (s *CardList) GetID() int { + return s.ID +} + +// GetCard returns the value of Card. +func (s *CardList) GetCard() OptInt { + return s.Card +} + +// GetStatus returns the value of Status. +func (s *CardList) GetStatus() OptString { + return s.Status +} + +// GetCp returns the value of Cp. +func (s *CardList) GetCp() OptInt { + return s.Cp +} + +// GetURL returns the value of URL. +func (s *CardList) GetURL() OptString { + return s.URL +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *CardList) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *CardList) SetID(val int) { + s.ID = val +} + +// SetCard sets the value of Card. +func (s *CardList) SetCard(val OptInt) { + s.Card = val +} + +// SetStatus sets the value of Status. +func (s *CardList) SetStatus(val OptString) { + s.Status = val +} + +// SetCp sets the value of Cp. +func (s *CardList) SetCp(val OptInt) { + s.Cp = val +} + +// SetURL sets the value of URL. +func (s *CardList) SetURL(val OptString) { + s.URL = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *CardList) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// Ref: #/components/schemas/Card_OwnerRead +type CardOwnerRead struct { + ID int `json:"id"` + Username string `json:"username"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + Next OptString `json:"next"` +} + +// GetID returns the value of ID. +func (s *CardOwnerRead) GetID() int { + return s.ID +} + +// GetUsername returns the value of Username. +func (s *CardOwnerRead) GetUsername() string { + return s.Username +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *CardOwnerRead) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *CardOwnerRead) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetNext returns the value of Next. +func (s *CardOwnerRead) GetNext() OptString { + return s.Next +} + +// SetID sets the value of ID. +func (s *CardOwnerRead) SetID(val int) { + s.ID = val +} + +// SetUsername sets the value of Username. +func (s *CardOwnerRead) SetUsername(val string) { + s.Username = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *CardOwnerRead) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *CardOwnerRead) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetNext sets the value of Next. +func (s *CardOwnerRead) SetNext(val OptString) { + s.Next = val +} + +func (*CardOwnerRead) readCardOwnerRes() {} + +// Ref: #/components/schemas/CardRead +type CardRead struct { + ID int `json:"id"` + Card OptInt `json:"card"` + Status OptString `json:"status"` + Cp OptInt `json:"cp"` + URL OptString `json:"url"` + CreatedAt OptDateTime `json:"created_at"` +} + +// GetID returns the value of ID. +func (s *CardRead) GetID() int { + return s.ID +} + +// GetCard returns the value of Card. +func (s *CardRead) GetCard() OptInt { + return s.Card +} + +// GetStatus returns the value of Status. +func (s *CardRead) GetStatus() OptString { + return s.Status +} + +// GetCp returns the value of Cp. +func (s *CardRead) GetCp() OptInt { + return s.Cp +} + +// GetURL returns the value of URL. +func (s *CardRead) GetURL() OptString { + return s.URL +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *CardRead) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *CardRead) SetID(val int) { + s.ID = val +} + +// SetCard sets the value of Card. +func (s *CardRead) SetCard(val OptInt) { + s.Card = val +} + +// SetStatus sets the value of Status. +func (s *CardRead) SetStatus(val OptString) { + s.Status = val +} + +// SetCp sets the value of Cp. +func (s *CardRead) SetCp(val OptInt) { + s.Cp = val +} + +// SetURL sets the value of URL. +func (s *CardRead) SetURL(val OptString) { + s.URL = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *CardRead) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +func (*CardRead) readCardRes() {} + +// Ref: #/components/schemas/CardUpdate +type CardUpdate struct { + ID int `json:"id"` + Card OptInt `json:"card"` + Status OptString `json:"status"` + Cp OptInt `json:"cp"` + URL OptString `json:"url"` + CreatedAt OptDateTime `json:"created_at"` +} + +// GetID returns the value of ID. +func (s *CardUpdate) GetID() int { + return s.ID +} + +// GetCard returns the value of Card. +func (s *CardUpdate) GetCard() OptInt { + return s.Card +} + +// GetStatus returns the value of Status. +func (s *CardUpdate) GetStatus() OptString { + return s.Status +} + +// GetCp returns the value of Cp. +func (s *CardUpdate) GetCp() OptInt { + return s.Cp +} + +// GetURL returns the value of URL. +func (s *CardUpdate) GetURL() OptString { + return s.URL +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *CardUpdate) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *CardUpdate) SetID(val int) { + s.ID = val +} + +// SetCard sets the value of Card. +func (s *CardUpdate) SetCard(val OptInt) { + s.Card = val +} + +// SetStatus sets the value of Status. +func (s *CardUpdate) SetStatus(val OptString) { + s.Status = val +} + +// SetCp sets the value of Cp. +func (s *CardUpdate) SetCp(val OptInt) { + s.Cp = val +} + +// SetURL sets the value of URL. +func (s *CardUpdate) SetURL(val OptString) { + s.URL = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *CardUpdate) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +func (*CardUpdate) updateCardRes() {} + +type CreateCardReq struct { + Card OptInt `json:"card"` + Status OptString `json:"status"` + Cp OptInt `json:"cp"` + URL OptString `json:"url"` + CreatedAt OptDateTime `json:"created_at"` + Owner int `json:"owner"` +} + +// GetCard returns the value of Card. +func (s *CreateCardReq) GetCard() OptInt { + return s.Card +} + +// GetStatus returns the value of Status. +func (s *CreateCardReq) GetStatus() OptString { + return s.Status +} + +// GetCp returns the value of Cp. +func (s *CreateCardReq) GetCp() OptInt { + return s.Cp +} + +// GetURL returns the value of URL. +func (s *CreateCardReq) GetURL() OptString { + return s.URL +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *CreateCardReq) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetOwner returns the value of Owner. +func (s *CreateCardReq) GetOwner() int { + return s.Owner +} + +// SetCard sets the value of Card. +func (s *CreateCardReq) SetCard(val OptInt) { + s.Card = val +} + +// SetStatus sets the value of Status. +func (s *CreateCardReq) SetStatus(val OptString) { + s.Status = val +} + +// SetCp sets the value of Cp. +func (s *CreateCardReq) SetCp(val OptInt) { + s.Cp = val +} + +// SetURL sets the value of URL. +func (s *CreateCardReq) SetURL(val OptString) { + s.URL = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *CreateCardReq) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetOwner sets the value of Owner. +func (s *CreateCardReq) SetOwner(val int) { + s.Owner = val +} + +type CreateGroupReq struct { + Name string `json:"name"` + Users []int `json:"users"` +} + +// GetName returns the value of Name. +func (s *CreateGroupReq) GetName() string { + return s.Name +} + +// GetUsers returns the value of Users. +func (s *CreateGroupReq) GetUsers() []int { + return s.Users +} + +// SetName sets the value of Name. +func (s *CreateGroupReq) SetName(val string) { + s.Name = val +} + +// SetUsers sets the value of Users. +func (s *CreateGroupReq) SetUsers(val []int) { + s.Users = val +} + +type CreateUserReq struct { + Username string `json:"username"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + Next OptString `json:"next"` + Card []int `json:"card"` +} + +// GetUsername returns the value of Username. +func (s *CreateUserReq) GetUsername() string { + return s.Username +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *CreateUserReq) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *CreateUserReq) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetNext returns the value of Next. +func (s *CreateUserReq) GetNext() OptString { + return s.Next +} + +// GetCard returns the value of Card. +func (s *CreateUserReq) GetCard() []int { + return s.Card +} + +// SetUsername sets the value of Username. +func (s *CreateUserReq) SetUsername(val string) { + s.Username = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *CreateUserReq) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *CreateUserReq) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetNext sets the value of Next. +func (s *CreateUserReq) SetNext(val OptString) { + s.Next = val +} + +// SetCard sets the value of Card. +func (s *CreateUserReq) SetCard(val []int) { + s.Card = val +} + +// DeleteCardNoContent is response for DeleteCard operation. +type DeleteCardNoContent struct{} + +func (*DeleteCardNoContent) deleteCardRes() {} + +// DeleteGroupNoContent is response for DeleteGroup operation. +type DeleteGroupNoContent struct{} + +func (*DeleteGroupNoContent) deleteGroupRes() {} + +// DeleteUserNoContent is response for DeleteUser operation. +type DeleteUserNoContent struct{} + +func (*DeleteUserNoContent) deleteUserRes() {} // DrawDoneNoContent is response for DrawDone operation. type DrawDoneNoContent struct{} @@ -102,56 +528,195 @@ type DrawDoneNoContent struct{} // DrawStartNoContent is response for DrawStart operation. type DrawStartNoContent struct{} -type ListUsersOKApplicationJSON []UsersList - -func (ListUsersOKApplicationJSON) listUsersRes() {} - -// NewOptBool returns new OptBool with value set to v. -func NewOptBool(v bool) OptBool { - return OptBool{ - Value: v, - Set: true, - } +// Ref: #/components/schemas/GroupCreate +type GroupCreate struct { + ID int `json:"id"` + Name string `json:"name"` } -// OptBool is optional bool. -type OptBool struct { - Value bool - Set bool +// GetID returns the value of ID. +func (s *GroupCreate) GetID() int { + return s.ID } -// IsSet returns true if OptBool was set. -func (o OptBool) IsSet() bool { return o.Set } - -// Reset unsets value. -func (o *OptBool) Reset() { - var v bool - o.Value = v - o.Set = false +// GetName returns the value of Name. +func (s *GroupCreate) GetName() string { + return s.Name } -// SetTo sets value to v. -func (o *OptBool) SetTo(v bool) { - o.Set = true - o.Value = v +// SetID sets the value of ID. +func (s *GroupCreate) SetID(val int) { + s.ID = val } -// Get returns value and boolean that denotes whether value was set. -func (o OptBool) Get() (v bool, ok bool) { - if !o.Set { - return v, false - } - return o.Value, true +// SetName sets the value of Name. +func (s *GroupCreate) SetName(val string) { + s.Name = val } -// Or returns value if set, or given parameter if does not. -func (o OptBool) Or(d bool) bool { - if v, ok := o.Get(); ok { - return v - } - return d +func (*GroupCreate) createGroupRes() {} + +// Ref: #/components/schemas/GroupList +type GroupList struct { + ID int `json:"id"` + Name string `json:"name"` } +// GetID returns the value of ID. +func (s *GroupList) GetID() int { + return s.ID +} + +// GetName returns the value of Name. +func (s *GroupList) GetName() string { + return s.Name +} + +// SetID sets the value of ID. +func (s *GroupList) SetID(val int) { + s.ID = val +} + +// SetName sets the value of Name. +func (s *GroupList) SetName(val string) { + s.Name = val +} + +// Ref: #/components/schemas/GroupRead +type GroupRead struct { + ID int `json:"id"` + Name string `json:"name"` +} + +// GetID returns the value of ID. +func (s *GroupRead) GetID() int { + return s.ID +} + +// GetName returns the value of Name. +func (s *GroupRead) GetName() string { + return s.Name +} + +// SetID sets the value of ID. +func (s *GroupRead) SetID(val int) { + s.ID = val +} + +// SetName sets the value of Name. +func (s *GroupRead) SetName(val string) { + s.Name = val +} + +func (*GroupRead) readGroupRes() {} + +// Ref: #/components/schemas/GroupUpdate +type GroupUpdate struct { + ID int `json:"id"` + Name string `json:"name"` +} + +// GetID returns the value of ID. +func (s *GroupUpdate) GetID() int { + return s.ID +} + +// GetName returns the value of Name. +func (s *GroupUpdate) GetName() string { + return s.Name +} + +// SetID sets the value of ID. +func (s *GroupUpdate) SetID(val int) { + s.ID = val +} + +// SetName sets the value of Name. +func (s *GroupUpdate) SetName(val string) { + s.Name = val +} + +func (*GroupUpdate) updateGroupRes() {} + +// Ref: #/components/schemas/Group_UsersList +type GroupUsersList struct { + ID int `json:"id"` + Username string `json:"username"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + Next OptString `json:"next"` +} + +// GetID returns the value of ID. +func (s *GroupUsersList) GetID() int { + return s.ID +} + +// GetUsername returns the value of Username. +func (s *GroupUsersList) GetUsername() string { + return s.Username +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *GroupUsersList) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *GroupUsersList) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetNext returns the value of Next. +func (s *GroupUsersList) GetNext() OptString { + return s.Next +} + +// SetID sets the value of ID. +func (s *GroupUsersList) SetID(val int) { + s.ID = val +} + +// SetUsername sets the value of Username. +func (s *GroupUsersList) SetUsername(val string) { + s.Username = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *GroupUsersList) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *GroupUsersList) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetNext sets the value of Next. +func (s *GroupUsersList) SetNext(val OptString) { + s.Next = val +} + +type ListCardOKApplicationJSON []CardList + +func (*ListCardOKApplicationJSON) listCardRes() {} + +type ListGroupOKApplicationJSON []GroupList + +func (*ListGroupOKApplicationJSON) listGroupRes() {} + +type ListGroupUsersOKApplicationJSON []GroupUsersList + +func (*ListGroupUsersOKApplicationJSON) listGroupUsersRes() {} + +type ListUserCardOKApplicationJSON []UserCardList + +func (*ListUserCardOKApplicationJSON) listUserCardRes() {} + +type ListUserOKApplicationJSON []UserList + +func (*ListUserOKApplicationJSON) listUserRes() {} + // NewOptDateTime returns new OptDateTime with value set to v. func NewOptDateTime(v time.Time) OptDateTime { return OptDateTime{ @@ -198,52 +763,6 @@ func (o OptDateTime) Or(d time.Time) time.Time { return d } -// NewOptFloat64 returns new OptFloat64 with value set to v. -func NewOptFloat64(v float64) OptFloat64 { - return OptFloat64{ - Value: v, - Set: true, - } -} - -// OptFloat64 is optional float64. -type OptFloat64 struct { - Value float64 - Set bool -} - -// IsSet returns true if OptFloat64 was set. -func (o OptFloat64) IsSet() bool { return o.Set } - -// Reset unsets value. -func (o *OptFloat64) Reset() { - var v float64 - o.Value = v - o.Set = false -} - -// SetTo sets value to v. -func (o *OptFloat64) SetTo(v float64) { - o.Set = true - o.Value = v -} - -// Get returns value and boolean that denotes whether value was set. -func (o OptFloat64) Get() (v float64, ok bool) { - if !o.Set { - return v, false - } - return o.Value, true -} - -// Or returns value if set, or given parameter if does not. -func (o OptFloat64) Or(d float64) float64 { - if v, ok := o.Get(); ok { - return v - } - return d -} - // NewOptInt returns new OptInt with value set to v. func NewOptInt(v int) OptInt { return OptInt{ @@ -337,161 +856,605 @@ func (o OptString) Or(d string) string { } type R400 struct { - Code int "json:\"code\"" - Status string "json:\"status\"" - Errors jx.Raw "json:\"errors\"" + Code int `json:"code"` + Status string `json:"status"` + Errors jx.Raw `json:"errors"` } -func (*R400) createUsersRes() {} -func (*R400) deleteUsersRes() {} -func (*R400) listUsersRes() {} -func (*R400) readUsersRes() {} -func (*R400) updateUsersRes() {} +// GetCode returns the value of Code. +func (s *R400) GetCode() int { + return s.Code +} + +// GetStatus returns the value of Status. +func (s *R400) GetStatus() string { + return s.Status +} + +// GetErrors returns the value of Errors. +func (s *R400) GetErrors() jx.Raw { + return s.Errors +} + +// SetCode sets the value of Code. +func (s *R400) SetCode(val int) { + s.Code = val +} + +// SetStatus sets the value of Status. +func (s *R400) SetStatus(val string) { + s.Status = val +} + +// SetErrors sets the value of Errors. +func (s *R400) SetErrors(val jx.Raw) { + s.Errors = val +} + +func (*R400) createCardRes() {} +func (*R400) createGroupRes() {} +func (*R400) createUserRes() {} +func (*R400) deleteCardRes() {} +func (*R400) deleteGroupRes() {} +func (*R400) deleteUserRes() {} +func (*R400) listCardRes() {} +func (*R400) listGroupRes() {} +func (*R400) listGroupUsersRes() {} +func (*R400) listUserCardRes() {} +func (*R400) listUserRes() {} +func (*R400) readCardOwnerRes() {} +func (*R400) readCardRes() {} +func (*R400) readGroupRes() {} +func (*R400) readUserRes() {} +func (*R400) updateCardRes() {} +func (*R400) updateGroupRes() {} +func (*R400) updateUserRes() {} type R404 struct { - Code int "json:\"code\"" - Status string "json:\"status\"" - Errors jx.Raw "json:\"errors\"" + Code int `json:"code"` + Status string `json:"status"` + Errors jx.Raw `json:"errors"` } -func (*R404) deleteUsersRes() {} -func (*R404) listUsersRes() {} -func (*R404) readUsersRes() {} -func (*R404) updateUsersRes() {} +// GetCode returns the value of Code. +func (s *R404) GetCode() int { + return s.Code +} + +// GetStatus returns the value of Status. +func (s *R404) GetStatus() string { + return s.Status +} + +// GetErrors returns the value of Errors. +func (s *R404) GetErrors() jx.Raw { + return s.Errors +} + +// SetCode sets the value of Code. +func (s *R404) SetCode(val int) { + s.Code = val +} + +// SetStatus sets the value of Status. +func (s *R404) SetStatus(val string) { + s.Status = val +} + +// SetErrors sets the value of Errors. +func (s *R404) SetErrors(val jx.Raw) { + s.Errors = val +} + +func (*R404) deleteCardRes() {} +func (*R404) deleteGroupRes() {} +func (*R404) deleteUserRes() {} +func (*R404) listCardRes() {} +func (*R404) listGroupRes() {} +func (*R404) listGroupUsersRes() {} +func (*R404) listUserCardRes() {} +func (*R404) listUserRes() {} +func (*R404) readCardOwnerRes() {} +func (*R404) readCardRes() {} +func (*R404) readGroupRes() {} +func (*R404) readUserRes() {} +func (*R404) updateCardRes() {} +func (*R404) updateGroupRes() {} +func (*R404) updateUserRes() {} type R409 struct { - Code int "json:\"code\"" - Status string "json:\"status\"" - Errors jx.Raw "json:\"errors\"" + Code int `json:"code"` + Status string `json:"status"` + Errors jx.Raw `json:"errors"` } -func (*R409) createUsersRes() {} -func (*R409) deleteUsersRes() {} -func (*R409) listUsersRes() {} -func (*R409) readUsersRes() {} -func (*R409) updateUsersRes() {} +// GetCode returns the value of Code. +func (s *R409) GetCode() int { + return s.Code +} + +// GetStatus returns the value of Status. +func (s *R409) GetStatus() string { + return s.Status +} + +// GetErrors returns the value of Errors. +func (s *R409) GetErrors() jx.Raw { + return s.Errors +} + +// SetCode sets the value of Code. +func (s *R409) SetCode(val int) { + s.Code = val +} + +// SetStatus sets the value of Status. +func (s *R409) SetStatus(val string) { + s.Status = val +} + +// SetErrors sets the value of Errors. +func (s *R409) SetErrors(val jx.Raw) { + s.Errors = val +} + +func (*R409) createCardRes() {} +func (*R409) createGroupRes() {} +func (*R409) createUserRes() {} +func (*R409) deleteCardRes() {} +func (*R409) deleteGroupRes() {} +func (*R409) deleteUserRes() {} +func (*R409) listCardRes() {} +func (*R409) listGroupRes() {} +func (*R409) listGroupUsersRes() {} +func (*R409) listUserCardRes() {} +func (*R409) listUserRes() {} +func (*R409) readCardOwnerRes() {} +func (*R409) readCardRes() {} +func (*R409) readGroupRes() {} +func (*R409) readUserRes() {} +func (*R409) updateCardRes() {} +func (*R409) updateGroupRes() {} +func (*R409) updateUserRes() {} type R500 struct { - Code int "json:\"code\"" - Status string "json:\"status\"" - Errors jx.Raw "json:\"errors\"" + Code int `json:"code"` + Status string `json:"status"` + Errors jx.Raw `json:"errors"` } -func (*R500) createUsersRes() {} -func (*R500) deleteUsersRes() {} -func (*R500) listUsersRes() {} -func (*R500) readUsersRes() {} -func (*R500) updateUsersRes() {} - -type UpdateUsersReq struct { - Hp OptInt "json:\"hp\"" - Attack OptInt "json:\"attack\"" - Defense OptInt "json:\"defense\"" - Critical OptInt "json:\"critical\"" - Battle OptInt "json:\"battle\"" - Win OptInt "json:\"win\"" - Day OptInt "json:\"day\"" - Percentage OptFloat64 "json:\"percentage\"" - Limit OptBool "json:\"limit\"" - Comment OptString "json:\"comment\"" - Next OptString "json:\"next\"" - UpdatedAt OptDateTime "json:\"updated_at\"" +// GetCode returns the value of Code. +func (s *R500) GetCode() int { + return s.Code } -// Ref: #/components/schemas/UsersCreate -type UsersCreate struct { - ID int "json:\"id\"" - User string "json:\"user\"" - Chara OptString "json:\"chara\"" - Skill OptInt "json:\"skill\"" - Hp OptInt "json:\"hp\"" - Attack OptInt "json:\"attack\"" - Defense OptInt "json:\"defense\"" - Critical OptInt "json:\"critical\"" - Battle OptInt "json:\"battle\"" - Win OptInt "json:\"win\"" - Day OptInt "json:\"day\"" - Percentage OptFloat64 "json:\"percentage\"" - Limit OptBool "json:\"limit\"" - Status OptString "json:\"status\"" - Comment OptString "json:\"comment\"" - CreatedAt OptDateTime "json:\"created_at\"" - Next OptString "json:\"next\"" - UpdatedAt OptDateTime "json:\"updated_at\"" - URL OptString "json:\"url\"" +// GetStatus returns the value of Status. +func (s *R500) GetStatus() string { + return s.Status } -func (*UsersCreate) createUsersRes() {} - -// Ref: #/components/schemas/UsersList -type UsersList struct { - ID int "json:\"id\"" - User string "json:\"user\"" - Chara OptString "json:\"chara\"" - Skill OptInt "json:\"skill\"" - Hp OptInt "json:\"hp\"" - Attack OptInt "json:\"attack\"" - Defense OptInt "json:\"defense\"" - Critical OptInt "json:\"critical\"" - Battle OptInt "json:\"battle\"" - Win OptInt "json:\"win\"" - Day OptInt "json:\"day\"" - Percentage OptFloat64 "json:\"percentage\"" - Limit OptBool "json:\"limit\"" - Status OptString "json:\"status\"" - Comment OptString "json:\"comment\"" - CreatedAt OptDateTime "json:\"created_at\"" - Next OptString "json:\"next\"" - UpdatedAt OptDateTime "json:\"updated_at\"" - URL OptString "json:\"url\"" +// GetErrors returns the value of Errors. +func (s *R500) GetErrors() jx.Raw { + return s.Errors } -// Ref: #/components/schemas/UsersRead -type UsersRead struct { - ID int "json:\"id\"" - User string "json:\"user\"" - Chara OptString "json:\"chara\"" - Skill OptInt "json:\"skill\"" - Hp OptInt "json:\"hp\"" - Attack OptInt "json:\"attack\"" - Defense OptInt "json:\"defense\"" - Critical OptInt "json:\"critical\"" - Battle OptInt "json:\"battle\"" - Win OptInt "json:\"win\"" - Day OptInt "json:\"day\"" - Percentage OptFloat64 "json:\"percentage\"" - Limit OptBool "json:\"limit\"" - Status OptString "json:\"status\"" - Comment OptString "json:\"comment\"" - CreatedAt OptDateTime "json:\"created_at\"" - Next OptString "json:\"next\"" - UpdatedAt OptDateTime "json:\"updated_at\"" - URL OptString "json:\"url\"" +// SetCode sets the value of Code. +func (s *R500) SetCode(val int) { + s.Code = val } -func (*UsersRead) readUsersRes() {} - -// Ref: #/components/schemas/UsersUpdate -type UsersUpdate struct { - ID int "json:\"id\"" - User string "json:\"user\"" - Chara OptString "json:\"chara\"" - Skill OptInt "json:\"skill\"" - Hp OptInt "json:\"hp\"" - Attack OptInt "json:\"attack\"" - Defense OptInt "json:\"defense\"" - Critical OptInt "json:\"critical\"" - Battle OptInt "json:\"battle\"" - Win OptInt "json:\"win\"" - Day OptInt "json:\"day\"" - Percentage OptFloat64 "json:\"percentage\"" - Limit OptBool "json:\"limit\"" - Status OptString "json:\"status\"" - Comment OptString "json:\"comment\"" - CreatedAt OptDateTime "json:\"created_at\"" - Next OptString "json:\"next\"" - UpdatedAt OptDateTime "json:\"updated_at\"" - URL OptString "json:\"url\"" +// SetStatus sets the value of Status. +func (s *R500) SetStatus(val string) { + s.Status = val } -func (*UsersUpdate) updateUsersRes() {} +// SetErrors sets the value of Errors. +func (s *R500) SetErrors(val jx.Raw) { + s.Errors = val +} + +func (*R500) createCardRes() {} +func (*R500) createGroupRes() {} +func (*R500) createUserRes() {} +func (*R500) deleteCardRes() {} +func (*R500) deleteGroupRes() {} +func (*R500) deleteUserRes() {} +func (*R500) listCardRes() {} +func (*R500) listGroupRes() {} +func (*R500) listGroupUsersRes() {} +func (*R500) listUserCardRes() {} +func (*R500) listUserRes() {} +func (*R500) readCardOwnerRes() {} +func (*R500) readCardRes() {} +func (*R500) readGroupRes() {} +func (*R500) readUserRes() {} +func (*R500) updateCardRes() {} +func (*R500) updateGroupRes() {} +func (*R500) updateUserRes() {} + +type UpdateCardReq struct { + Owner OptInt `json:"owner"` +} + +// GetOwner returns the value of Owner. +func (s *UpdateCardReq) GetOwner() OptInt { + return s.Owner +} + +// SetOwner sets the value of Owner. +func (s *UpdateCardReq) SetOwner(val OptInt) { + s.Owner = val +} + +type UpdateGroupReq struct { + Name OptString `json:"name"` + Users []int `json:"users"` +} + +// GetName returns the value of Name. +func (s *UpdateGroupReq) GetName() OptString { + return s.Name +} + +// GetUsers returns the value of Users. +func (s *UpdateGroupReq) GetUsers() []int { + return s.Users +} + +// SetName sets the value of Name. +func (s *UpdateGroupReq) SetName(val OptString) { + s.Name = val +} + +// SetUsers sets the value of Users. +func (s *UpdateGroupReq) SetUsers(val []int) { + s.Users = val +} + +type UpdateUserReq struct { + UpdatedAt OptDateTime `json:"updated_at"` + Next OptString `json:"next"` + Card []int `json:"card"` +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *UpdateUserReq) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetNext returns the value of Next. +func (s *UpdateUserReq) GetNext() OptString { + return s.Next +} + +// GetCard returns the value of Card. +func (s *UpdateUserReq) GetCard() []int { + return s.Card +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *UpdateUserReq) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetNext sets the value of Next. +func (s *UpdateUserReq) SetNext(val OptString) { + s.Next = val +} + +// SetCard sets the value of Card. +func (s *UpdateUserReq) SetCard(val []int) { + s.Card = val +} + +// Ref: #/components/schemas/User_CardList +type UserCardList struct { + ID int `json:"id"` + Card OptInt `json:"card"` + Status OptString `json:"status"` + Cp OptInt `json:"cp"` + URL OptString `json:"url"` + CreatedAt OptDateTime `json:"created_at"` +} + +// GetID returns the value of ID. +func (s *UserCardList) GetID() int { + return s.ID +} + +// GetCard returns the value of Card. +func (s *UserCardList) GetCard() OptInt { + return s.Card +} + +// GetStatus returns the value of Status. +func (s *UserCardList) GetStatus() OptString { + return s.Status +} + +// GetCp returns the value of Cp. +func (s *UserCardList) GetCp() OptInt { + return s.Cp +} + +// GetURL returns the value of URL. +func (s *UserCardList) GetURL() OptString { + return s.URL +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserCardList) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *UserCardList) SetID(val int) { + s.ID = val +} + +// SetCard sets the value of Card. +func (s *UserCardList) SetCard(val OptInt) { + s.Card = val +} + +// SetStatus sets the value of Status. +func (s *UserCardList) SetStatus(val OptString) { + s.Status = val +} + +// SetCp sets the value of Cp. +func (s *UserCardList) SetCp(val OptInt) { + s.Cp = val +} + +// SetURL sets the value of URL. +func (s *UserCardList) SetURL(val OptString) { + s.URL = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserCardList) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// Ref: #/components/schemas/UserCreate +type UserCreate struct { + ID int `json:"id"` + Username string `json:"username"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + Next OptString `json:"next"` +} + +// GetID returns the value of ID. +func (s *UserCreate) GetID() int { + return s.ID +} + +// GetUsername returns the value of Username. +func (s *UserCreate) GetUsername() string { + return s.Username +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserCreate) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *UserCreate) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetNext returns the value of Next. +func (s *UserCreate) GetNext() OptString { + return s.Next +} + +// SetID sets the value of ID. +func (s *UserCreate) SetID(val int) { + s.ID = val +} + +// SetUsername sets the value of Username. +func (s *UserCreate) SetUsername(val string) { + s.Username = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserCreate) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *UserCreate) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetNext sets the value of Next. +func (s *UserCreate) SetNext(val OptString) { + s.Next = val +} + +func (*UserCreate) createUserRes() {} + +// Ref: #/components/schemas/UserList +type UserList struct { + ID int `json:"id"` + Username string `json:"username"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + Next OptString `json:"next"` +} + +// GetID returns the value of ID. +func (s *UserList) GetID() int { + return s.ID +} + +// GetUsername returns the value of Username. +func (s *UserList) GetUsername() string { + return s.Username +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserList) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *UserList) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetNext returns the value of Next. +func (s *UserList) GetNext() OptString { + return s.Next +} + +// SetID sets the value of ID. +func (s *UserList) SetID(val int) { + s.ID = val +} + +// SetUsername sets the value of Username. +func (s *UserList) SetUsername(val string) { + s.Username = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserList) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *UserList) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetNext sets the value of Next. +func (s *UserList) SetNext(val OptString) { + s.Next = val +} + +// Ref: #/components/schemas/UserRead +type UserRead struct { + ID int `json:"id"` + Username string `json:"username"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + Next OptString `json:"next"` +} + +// GetID returns the value of ID. +func (s *UserRead) GetID() int { + return s.ID +} + +// GetUsername returns the value of Username. +func (s *UserRead) GetUsername() string { + return s.Username +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserRead) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *UserRead) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetNext returns the value of Next. +func (s *UserRead) GetNext() OptString { + return s.Next +} + +// SetID sets the value of ID. +func (s *UserRead) SetID(val int) { + s.ID = val +} + +// SetUsername sets the value of Username. +func (s *UserRead) SetUsername(val string) { + s.Username = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserRead) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *UserRead) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetNext sets the value of Next. +func (s *UserRead) SetNext(val OptString) { + s.Next = val +} + +func (*UserRead) readUserRes() {} + +// Ref: #/components/schemas/UserUpdate +type UserUpdate struct { + ID int `json:"id"` + Username string `json:"username"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + Next OptString `json:"next"` +} + +// GetID returns the value of ID. +func (s *UserUpdate) GetID() int { + return s.ID +} + +// GetUsername returns the value of Username. +func (s *UserUpdate) GetUsername() string { + return s.Username +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserUpdate) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetUpdatedAt returns the value of UpdatedAt. +func (s *UserUpdate) GetUpdatedAt() OptDateTime { + return s.UpdatedAt +} + +// GetNext returns the value of Next. +func (s *UserUpdate) GetNext() OptString { + return s.Next +} + +// SetID sets the value of ID. +func (s *UserUpdate) SetID(val int) { + s.ID = val +} + +// SetUsername sets the value of Username. +func (s *UserUpdate) SetUsername(val string) { + s.Username = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserUpdate) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetUpdatedAt sets the value of UpdatedAt. +func (s *UserUpdate) SetUpdatedAt(val OptDateTime) { + s.UpdatedAt = val +} + +// SetNext sets the value of Next. +func (s *UserUpdate) SetNext(val OptString) { + s.Next = val +} + +func (*UserUpdate) updateUserRes() {} diff --git a/ent/ogent/oas_security_gen.go b/ent/ogent/oas_security_gen.go deleted file mode 100644 index 384bf65..0000000 --- a/ent/ogent/oas_security_gen.go +++ /dev/null @@ -1,71 +0,0 @@ -// Code generated by ogen, DO NOT EDIT. - -package ogent - -import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" -) - -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) diff --git a/ent/ogent/oas_server_gen.go b/ent/ogent/oas_server_gen.go index 3e65138..9d3d350 100644 --- a/ent/ogent/oas_server_gen.go +++ b/ent/ogent/oas_server_gen.go @@ -3,140 +3,148 @@ package ogent import ( - "bytes" "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" -) - -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset ) // Handler handles operations described by OpenAPI v3 specification. type Handler interface { - // CreateUsers implements createUsers operation. + // CreateCard implements createCard operation. // - // Creates a new Users and persists it to storage. + // Creates a new Card and persists it to storage. + // + // POST /cards + CreateCard(ctx context.Context, req *CreateCardReq) (CreateCardRes, error) + // CreateGroup implements createGroup operation. + // + // Creates a new Group and persists it to storage. + // + // POST /groups + CreateGroup(ctx context.Context, req *CreateGroupReq) (CreateGroupRes, error) + // CreateUser implements createUser operation. + // + // Creates a new User and persists it to storage. // // POST /users - CreateUsers(ctx context.Context, req CreateUsersReq) (CreateUsersRes, error) - // DeleteUsers implements deleteUsers operation. + CreateUser(ctx context.Context, req *CreateUserReq) (CreateUserRes, error) + // DeleteCard implements deleteCard operation. // - // Deletes the Users with the requested ID. + // Deletes the Card with the requested ID. + // + // DELETE /cards/{id} + DeleteCard(ctx context.Context, params DeleteCardParams) (DeleteCardRes, error) + // DeleteGroup implements deleteGroup operation. + // + // Deletes the Group with the requested ID. + // + // DELETE /groups/{id} + DeleteGroup(ctx context.Context, params DeleteGroupParams) (DeleteGroupRes, error) + // DeleteUser implements deleteUser operation. + // + // Deletes the User with the requested ID. // // DELETE /users/{id} - DeleteUsers(ctx context.Context, params DeleteUsersParams) (DeleteUsersRes, error) + DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error) // DrawDone implements drawDone operation. // - // PUT /users/{id}/d - DrawDone(ctx context.Context, params DrawDoneParams) (DrawDoneNoContent, error) + // Draws a card item as done. + // + // PUT /cards/{id}/d + DrawDone(ctx context.Context, params DrawDoneParams) error // DrawStart implements drawStart operation. // - // PATCH /users/{id}/start - DrawStart(ctx context.Context, params DrawStartParams) (DrawStartNoContent, error) - // ListUsers implements listUsers operation. + // Draws a card item as done. + // + // PATCH /users/{id}/card/start + DrawStart(ctx context.Context, params DrawStartParams) error + // ListCard implements listCard operation. + // + // List Cards. + // + // GET /cards + ListCard(ctx context.Context, params ListCardParams) (ListCardRes, error) + // ListGroup implements listGroup operation. + // + // List Groups. + // + // GET /groups + ListGroup(ctx context.Context, params ListGroupParams) (ListGroupRes, error) + // ListGroupUsers implements listGroupUsers operation. + // + // List attached Users. + // + // GET /groups/{id}/users + ListGroupUsers(ctx context.Context, params ListGroupUsersParams) (ListGroupUsersRes, error) + // ListUser implements listUser operation. // // List Users. // // GET /users - ListUsers(ctx context.Context, params ListUsersParams) (ListUsersRes, error) - // ReadUsers implements readUsers operation. + ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error) + // ListUserCard implements listUserCard operation. // - // Finds the Users with the requested ID and returns it. + // List attached Cards. + // + // GET /users/{id}/card + ListUserCard(ctx context.Context, params ListUserCardParams) (ListUserCardRes, error) + // ReadCard implements readCard operation. + // + // Finds the Card with the requested ID and returns it. + // + // GET /cards/{id} + ReadCard(ctx context.Context, params ReadCardParams) (ReadCardRes, error) + // ReadCardOwner implements readCardOwner operation. + // + // Find the attached User of the Card with the given ID. + // + // GET /cards/{id}/owner + ReadCardOwner(ctx context.Context, params ReadCardOwnerParams) (ReadCardOwnerRes, error) + // ReadGroup implements readGroup operation. + // + // Finds the Group with the requested ID and returns it. + // + // GET /groups/{id} + ReadGroup(ctx context.Context, params ReadGroupParams) (ReadGroupRes, error) + // ReadUser implements readUser operation. + // + // Finds the User with the requested ID and returns it. // // GET /users/{id} - ReadUsers(ctx context.Context, params ReadUsersParams) (ReadUsersRes, error) - // UpdateUsers implements updateUsers operation. + ReadUser(ctx context.Context, params ReadUserParams) (ReadUserRes, error) + // UpdateCard implements updateCard operation. // - // Updates a Users and persists changes to storage. + // Updates a Card and persists changes to storage. + // + // PATCH /cards/{id} + UpdateCard(ctx context.Context, req *UpdateCardReq, params UpdateCardParams) (UpdateCardRes, error) + // UpdateGroup implements updateGroup operation. + // + // Updates a Group and persists changes to storage. + // + // PATCH /groups/{id} + UpdateGroup(ctx context.Context, req *UpdateGroupReq, params UpdateGroupParams) (UpdateGroupRes, error) + // UpdateUser implements updateUser operation. + // + // Updates a User and persists changes to storage. // // PATCH /users/{id} - UpdateUsers(ctx context.Context, req UpdateUsersReq, params UpdateUsersParams) (UpdateUsersRes, error) + UpdateUser(ctx context.Context, req *UpdateUserReq, params UpdateUserParams) (UpdateUserRes, error) } // Server implements http server based on OpenAPI v3 specification and // calls Handler to handle requests. type Server struct { - h Handler - cfg config - - requests metric.Int64Counter - errors metric.Int64Counter - duration metric.Int64Histogram + h Handler + baseServer } -func NewServer(h Handler, opts ...Option) (*Server, error) { - s := &Server{ - h: h, - cfg: newConfig(opts...), - } - var err error - if s.requests, err = s.cfg.Meter.NewInt64Counter(otelogen.ServerRequestCount); err != nil { +// NewServer creates new Server. +func NewServer(h Handler, opts ...ServerOption) (*Server, error) { + s, err := newServerConfig(opts...).baseServer() + if err != nil { return nil, err } - if s.errors, err = s.cfg.Meter.NewInt64Counter(otelogen.ServerErrorsCount); err != nil { - return nil, err - } - if s.duration, err = s.cfg.Meter.NewInt64Histogram(otelogen.ServerDuration); err != nil { - return nil, err - } - return s, nil + return &Server{ + h: h, + baseServer: s, + }, nil } diff --git a/ent/ogent/oas_unimplemented_gen.go b/ent/ogent/oas_unimplemented_gen.go index fa6427a..3a7db56 100644 --- a/ent/ogent/oas_unimplemented_gen.go +++ b/ent/ogent/oas_unimplemented_gen.go @@ -3,133 +3,192 @@ package ogent import ( - "bytes" "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" ) -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) - -var _ Handler = UnimplementedHandler{} - // UnimplementedHandler is no-op Handler which returns http.ErrNotImplemented. type UnimplementedHandler struct{} -// CreateUsers implements createUsers operation. +var _ Handler = UnimplementedHandler{} + +// CreateCard implements createCard operation. // -// Creates a new Users and persists it to storage. +// Creates a new Card and persists it to storage. // -// POST /users -func (UnimplementedHandler) CreateUsers(ctx context.Context, req CreateUsersReq) (r CreateUsersRes, _ error) { +// POST /cards +func (UnimplementedHandler) CreateCard(ctx context.Context, req *CreateCardReq) (r CreateCardRes, _ error) { return r, ht.ErrNotImplemented } -// DeleteUsers implements deleteUsers operation. +// CreateGroup implements createGroup operation. // -// Deletes the Users with the requested ID. +// Creates a new Group and persists it to storage. +// +// POST /groups +func (UnimplementedHandler) CreateGroup(ctx context.Context, req *CreateGroupReq) (r CreateGroupRes, _ error) { + return r, ht.ErrNotImplemented +} + +// CreateUser implements createUser operation. +// +// Creates a new User and persists it to storage. +// +// POST /users +func (UnimplementedHandler) CreateUser(ctx context.Context, req *CreateUserReq) (r CreateUserRes, _ error) { + return r, ht.ErrNotImplemented +} + +// DeleteCard implements deleteCard operation. +// +// Deletes the Card with the requested ID. +// +// DELETE /cards/{id} +func (UnimplementedHandler) DeleteCard(ctx context.Context, params DeleteCardParams) (r DeleteCardRes, _ error) { + return r, ht.ErrNotImplemented +} + +// DeleteGroup implements deleteGroup operation. +// +// Deletes the Group with the requested ID. +// +// DELETE /groups/{id} +func (UnimplementedHandler) DeleteGroup(ctx context.Context, params DeleteGroupParams) (r DeleteGroupRes, _ error) { + return r, ht.ErrNotImplemented +} + +// DeleteUser implements deleteUser operation. +// +// Deletes the User with the requested ID. // // DELETE /users/{id} -func (UnimplementedHandler) DeleteUsers(ctx context.Context, params DeleteUsersParams) (r DeleteUsersRes, _ error) { +func (UnimplementedHandler) DeleteUser(ctx context.Context, params DeleteUserParams) (r DeleteUserRes, _ error) { return r, ht.ErrNotImplemented } // DrawDone implements drawDone operation. // -// PUT /users/{id}/d -func (UnimplementedHandler) DrawDone(ctx context.Context, params DrawDoneParams) (r DrawDoneNoContent, _ error) { - return r, ht.ErrNotImplemented +// Draws a card item as done. +// +// PUT /cards/{id}/d +func (UnimplementedHandler) DrawDone(ctx context.Context, params DrawDoneParams) error { + return ht.ErrNotImplemented } // DrawStart implements drawStart operation. // -// PATCH /users/{id}/start -func (UnimplementedHandler) DrawStart(ctx context.Context, params DrawStartParams) (r DrawStartNoContent, _ error) { +// Draws a card item as done. +// +// PATCH /users/{id}/card/start +func (UnimplementedHandler) DrawStart(ctx context.Context, params DrawStartParams) error { + return ht.ErrNotImplemented +} + +// ListCard implements listCard operation. +// +// List Cards. +// +// GET /cards +func (UnimplementedHandler) ListCard(ctx context.Context, params ListCardParams) (r ListCardRes, _ error) { return r, ht.ErrNotImplemented } -// ListUsers implements listUsers operation. +// ListGroup implements listGroup operation. +// +// List Groups. +// +// GET /groups +func (UnimplementedHandler) ListGroup(ctx context.Context, params ListGroupParams) (r ListGroupRes, _ error) { + return r, ht.ErrNotImplemented +} + +// ListGroupUsers implements listGroupUsers operation. +// +// List attached Users. +// +// GET /groups/{id}/users +func (UnimplementedHandler) ListGroupUsers(ctx context.Context, params ListGroupUsersParams) (r ListGroupUsersRes, _ error) { + return r, ht.ErrNotImplemented +} + +// ListUser implements listUser operation. // // List Users. // // GET /users -func (UnimplementedHandler) ListUsers(ctx context.Context, params ListUsersParams) (r ListUsersRes, _ error) { +func (UnimplementedHandler) ListUser(ctx context.Context, params ListUserParams) (r ListUserRes, _ error) { return r, ht.ErrNotImplemented } -// ReadUsers implements readUsers operation. +// ListUserCard implements listUserCard operation. // -// Finds the Users with the requested ID and returns it. +// List attached Cards. +// +// GET /users/{id}/card +func (UnimplementedHandler) ListUserCard(ctx context.Context, params ListUserCardParams) (r ListUserCardRes, _ error) { + return r, ht.ErrNotImplemented +} + +// ReadCard implements readCard operation. +// +// Finds the Card with the requested ID and returns it. +// +// GET /cards/{id} +func (UnimplementedHandler) ReadCard(ctx context.Context, params ReadCardParams) (r ReadCardRes, _ error) { + return r, ht.ErrNotImplemented +} + +// ReadCardOwner implements readCardOwner operation. +// +// Find the attached User of the Card with the given ID. +// +// GET /cards/{id}/owner +func (UnimplementedHandler) ReadCardOwner(ctx context.Context, params ReadCardOwnerParams) (r ReadCardOwnerRes, _ error) { + return r, ht.ErrNotImplemented +} + +// ReadGroup implements readGroup operation. +// +// Finds the Group with the requested ID and returns it. +// +// GET /groups/{id} +func (UnimplementedHandler) ReadGroup(ctx context.Context, params ReadGroupParams) (r ReadGroupRes, _ error) { + return r, ht.ErrNotImplemented +} + +// ReadUser implements readUser operation. +// +// Finds the User with the requested ID and returns it. // // GET /users/{id} -func (UnimplementedHandler) ReadUsers(ctx context.Context, params ReadUsersParams) (r ReadUsersRes, _ error) { +func (UnimplementedHandler) ReadUser(ctx context.Context, params ReadUserParams) (r ReadUserRes, _ error) { return r, ht.ErrNotImplemented } -// UpdateUsers implements updateUsers operation. +// UpdateCard implements updateCard operation. // -// Updates a Users and persists changes to storage. +// Updates a Card and persists changes to storage. // -// PATCH /users/{id} -func (UnimplementedHandler) UpdateUsers(ctx context.Context, req UpdateUsersReq, params UpdateUsersParams) (r UpdateUsersRes, _ error) { +// PATCH /cards/{id} +func (UnimplementedHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, params UpdateCardParams) (r UpdateCardRes, _ error) { + return r, ht.ErrNotImplemented +} + +// UpdateGroup implements updateGroup operation. +// +// Updates a Group and persists changes to storage. +// +// PATCH /groups/{id} +func (UnimplementedHandler) UpdateGroup(ctx context.Context, req *UpdateGroupReq, params UpdateGroupParams) (r UpdateGroupRes, _ error) { + return r, ht.ErrNotImplemented +} + +// UpdateUser implements updateUser operation. +// +// Updates a User and persists changes to storage. +// +// PATCH /users/{id} +func (UnimplementedHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, params UpdateUserParams) (r UpdateUserRes, _ error) { return r, ht.ErrNotImplemented } diff --git a/ent/ogent/oas_validators_gen.go b/ent/ogent/oas_validators_gen.go index d9d9bec..be92ecd 100644 --- a/ent/ogent/oas_validators_gen.go +++ b/ent/ogent/oas_validators_gen.go @@ -3,250 +3,36 @@ package ogent import ( - "bytes" - "context" - "fmt" - "io" - "math" - "math/big" - "math/bits" - "net" - "net/http" - "net/url" - "regexp" - "sort" - "strconv" - "strings" - "sync" - "time" - "github.com/go-faster/errors" - "github.com/go-faster/jx" - "github.com/google/uuid" - "github.com/ogen-go/ogen/conv" - ht "github.com/ogen-go/ogen/http" - "github.com/ogen-go/ogen/json" - "github.com/ogen-go/ogen/otelogen" - "github.com/ogen-go/ogen/uri" - "github.com/ogen-go/ogen/validate" - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - "go.opentelemetry.io/otel/trace" ) -// No-op definition for keeping imports. -var ( - _ = context.Background() - _ = fmt.Stringer(nil) - _ = strings.Builder{} - _ = errors.Is - _ = sort.Ints - _ = http.MethodGet - _ = io.Copy - _ = json.Marshal - _ = bytes.NewReader - _ = strconv.ParseInt - _ = time.Time{} - _ = conv.ToInt32 - _ = uuid.UUID{} - _ = uri.PathEncoder{} - _ = url.URL{} - _ = math.Mod - _ = bits.LeadingZeros64 - _ = big.Rat{} - _ = validate.Int{} - _ = ht.NewRequest - _ = net.IP{} - _ = otelogen.Version - _ = attribute.KeyValue{} - _ = trace.TraceIDFromHex - _ = otel.GetTracerProvider - _ = metric.NewNoopMeterProvider - _ = regexp.MustCompile - _ = jx.Null - _ = sync.Pool{} - _ = codes.Unset -) - -func (s CreateUsersReq) Validate() error { - var failures []validate.FieldError - if err := func() error { - if s.Percentage.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "percentage", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil -} -func (s ListUsersOKApplicationJSON) Validate() error { +func (s ListCardOKApplicationJSON) Validate() error { if s == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range s { - if err := func() error { - if err := elem.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} + return nil +} +func (s ListGroupOKApplicationJSON) Validate() error { + if s == nil { + return errors.New("nil is invalid value") } return nil } - -func (s UpdateUsersReq) Validate() error { - var failures []validate.FieldError - if err := func() error { - if s.Percentage.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "percentage", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} +func (s ListGroupUsersOKApplicationJSON) Validate() error { + if s == nil { + return errors.New("nil is invalid value") } return nil } -func (s UsersCreate) Validate() error { - var failures []validate.FieldError - if err := func() error { - if s.Percentage.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "percentage", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} +func (s ListUserCardOKApplicationJSON) Validate() error { + if s == nil { + return errors.New("nil is invalid value") } return nil } -func (s UsersList) Validate() error { - var failures []validate.FieldError - if err := func() error { - if s.Percentage.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "percentage", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil -} -func (s UsersRead) Validate() error { - var failures []validate.FieldError - if err := func() error { - if s.Percentage.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "percentage", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil -} -func (s UsersUpdate) Validate() error { - var failures []validate.FieldError - if err := func() error { - if s.Percentage.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "percentage", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} +func (s ListUserOKApplicationJSON) Validate() error { + if s == nil { + return errors.New("nil is invalid value") } return nil } diff --git a/ent/ogent/ogent.go b/ent/ogent/ogent.go index d878170..d734ed3 100644 --- a/ent/ogent/ogent.go +++ b/ent/ogent/ogent.go @@ -1,4 +1,4 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package ogent @@ -7,7 +7,9 @@ import ( "net/http" "t/ent" - "t/ent/users" + "t/ent/card" + "t/ent/group" + "t/ent/user" "github.com/go-faster/jx" ) @@ -27,63 +29,27 @@ func rawError(err error) jx.Raw { return e.Bytes() } -// CreateUsers handles POST /users-slice requests. -func (h *OgentHandler) CreateUsers(ctx context.Context, req CreateUsersReq) (CreateUsersRes, error) { - b := h.client.Users.Create() +// CreateCard handles POST /cards requests. +func (h *OgentHandler) CreateCard(ctx context.Context, req *CreateCardReq) (CreateCardRes, error) { + b := h.client.Card.Create() // Add all fields. - b.SetUser(req.User) - if v, ok := req.Chara.Get(); ok { - b.SetChara(v) - } - if v, ok := req.Skill.Get(); ok { - b.SetSkill(v) - } - if v, ok := req.Hp.Get(); ok { - b.SetHp(v) - } - if v, ok := req.Attack.Get(); ok { - b.SetAttack(v) - } - if v, ok := req.Defense.Get(); ok { - b.SetDefense(v) - } - if v, ok := req.Critical.Get(); ok { - b.SetCritical(v) - } - if v, ok := req.Battle.Get(); ok { - b.SetBattle(v) - } - if v, ok := req.Win.Get(); ok { - b.SetWin(v) - } - if v, ok := req.Day.Get(); ok { - b.SetDay(v) - } - if v, ok := req.Percentage.Get(); ok { - b.SetPercentage(v) - } - if v, ok := req.Limit.Get(); ok { - b.SetLimit(v) + if v, ok := req.Card.Get(); ok { + b.SetCard(v) } if v, ok := req.Status.Get(); ok { b.SetStatus(v) } - if v, ok := req.Comment.Get(); ok { - b.SetComment(v) - } - if v, ok := req.CreatedAt.Get(); ok { - b.SetCreatedAt(v) - } - if v, ok := req.Next.Get(); ok { - b.SetNext(v) - } - if v, ok := req.UpdatedAt.Get(); ok { - b.SetUpdatedAt(v) + if v, ok := req.Cp.Get(); ok { + b.SetCp(v) } if v, ok := req.URL.Get(); ok { b.SetURL(v) } + if v, ok := req.CreatedAt.Get(); ok { + b.SetCreatedAt(v) + } // Add all edges. + b.SetOwnerID(req.Owner) // Persist to storage. e, err := b.Save(ctx) if err != nil { @@ -106,18 +72,18 @@ func (h *OgentHandler) CreateUsers(ctx context.Context, req CreateUsersReq) (Cre } } // Reload the entity to attach all eager-loaded edges. - q := h.client.Users.Query().Where(users.ID(e.ID)) + q := h.client.Card.Query().Where(card.ID(e.ID)) e, err = q.Only(ctx) if err != nil { // This should never happen. return nil, err } - return NewUsersCreate(e), nil + return NewCardCreate(e), nil } -// ReadUsers handles GET /users-slice/{id} requests. -func (h *OgentHandler) ReadUsers(ctx context.Context, params ReadUsersParams) (ReadUsersRes, error) { - q := h.client.Users.Query().Where(users.IDEQ(params.ID)) +// ReadCard handles GET /cards/{id} requests. +func (h *OgentHandler) ReadCard(ctx context.Context, params ReadCardParams) (ReadCardRes, error) { + q := h.client.Card.Query().Where(card.IDEQ(params.ID)) e, err := q.Only(ctx) if err != nil { switch { @@ -138,50 +104,17 @@ func (h *OgentHandler) ReadUsers(ctx context.Context, params ReadUsersParams) (R return nil, err } } - return NewUsersRead(e), nil + return NewCardRead(e), nil } -// UpdateUsers handles PATCH /users-slice/{id} requests. -func (h *OgentHandler) UpdateUsers(ctx context.Context, req UpdateUsersReq, params UpdateUsersParams) (UpdateUsersRes, error) { - b := h.client.Users.UpdateOneID(params.ID) +// UpdateCard handles PATCH /cards/{id} requests. +func (h *OgentHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, params UpdateCardParams) (UpdateCardRes, error) { + b := h.client.Card.UpdateOneID(params.ID) // Add all fields. - if v, ok := req.Hp.Get(); ok { - b.SetHp(v) - } - if v, ok := req.Attack.Get(); ok { - b.SetAttack(v) - } - if v, ok := req.Defense.Get(); ok { - b.SetDefense(v) - } - if v, ok := req.Critical.Get(); ok { - b.SetCritical(v) - } - if v, ok := req.Battle.Get(); ok { - b.SetBattle(v) - } - if v, ok := req.Win.Get(); ok { - b.SetWin(v) - } - if v, ok := req.Day.Get(); ok { - b.SetDay(v) - } - if v, ok := req.Percentage.Get(); ok { - b.SetPercentage(v) - } - if v, ok := req.Limit.Get(); ok { - b.SetLimit(v) - } - if v, ok := req.Comment.Get(); ok { - b.SetComment(v) - } - if v, ok := req.Next.Get(); ok { - b.SetNext(v) - } - if v, ok := req.UpdatedAt.Get(); ok { - b.SetUpdatedAt(v) - } // Add all edges. + if v, ok := req.Owner.Get(); ok { + b.SetOwnerID(v) + } // Persist to storage. e, err := b.Save(ctx) if err != nil { @@ -204,18 +137,18 @@ func (h *OgentHandler) UpdateUsers(ctx context.Context, req UpdateUsersReq, para } } // Reload the entity to attach all eager-loaded edges. - q := h.client.Users.Query().Where(users.ID(e.ID)) + q := h.client.Card.Query().Where(card.ID(e.ID)) e, err = q.Only(ctx) if err != nil { // This should never happen. return nil, err } - return NewUsersUpdate(e), nil + return NewCardUpdate(e), nil } -// DeleteUsers handles DELETE /users-slice/{id} requests. -func (h *OgentHandler) DeleteUsers(ctx context.Context, params DeleteUsersParams) (DeleteUsersRes, error) { - err := h.client.Users.DeleteOneID(params.ID).Exec(ctx) +// DeleteCard handles DELETE /cards/{id} requests. +func (h *OgentHandler) DeleteCard(ctx context.Context, params DeleteCardParams) (DeleteCardRes, error) { + err := h.client.Card.DeleteOneID(params.ID).Exec(ctx) if err != nil { switch { case ent.IsNotFound(err): @@ -235,13 +168,13 @@ func (h *OgentHandler) DeleteUsers(ctx context.Context, params DeleteUsersParams return nil, err } } - return new(DeleteUsersNoContent), nil + return new(DeleteCardNoContent), nil } -// ListUsers handles GET /users-slice requests. -func (h *OgentHandler) ListUsers(ctx context.Context, params ListUsersParams) (ListUsersRes, error) { - q := h.client.Users.Query() +// ListCard handles GET /cards requests. +func (h *OgentHandler) ListCard(ctx context.Context, params ListCardParams) (ListCardRes, error) { + q := h.client.Card.Query() page := 1 if v, ok := params.Page.Get(); ok { page = v @@ -250,7 +183,9 @@ func (h *OgentHandler) ListUsers(ctx context.Context, params ListUsersParams) (L if v, ok := params.ItemsPerPage.Get(); ok { itemsPerPage = v } - es, err := q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage).All(ctx) + q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage) + + es, err := q.All(ctx) if err != nil { switch { case ent.IsNotFound(err): @@ -270,5 +205,454 @@ func (h *OgentHandler) ListUsers(ctx context.Context, params ListUsersParams) (L return nil, err } } - return ListUsersOKApplicationJSON(NewUsersLists(es)), nil + r := NewCardLists(es) + return (*ListCardOKApplicationJSON)(&r), nil +} + +// ReadCardOwner handles GET /cards/{id}/owner requests. +func (h *OgentHandler) ReadCardOwner(ctx context.Context, params ReadCardOwnerParams) (ReadCardOwnerRes, error) { + q := h.client.Card.Query().Where(card.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 NewCardOwnerRead(e), nil +} + +// CreateGroup handles POST /groups requests. +func (h *OgentHandler) CreateGroup(ctx context.Context, req *CreateGroupReq) (CreateGroupRes, error) { + b := h.client.Group.Create() + // Add all fields. + b.SetName(req.Name) + // Add all edges. + b.AddUserIDs(req.Users...) + // 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.Group.Query().Where(group.ID(e.ID)) + e, err = q.Only(ctx) + if err != nil { + // This should never happen. + return nil, err + } + return NewGroupCreate(e), nil +} + +// ReadGroup handles GET /groups/{id} requests. +func (h *OgentHandler) ReadGroup(ctx context.Context, params ReadGroupParams) (ReadGroupRes, error) { + q := h.client.Group.Query().Where(group.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 NewGroupRead(e), nil +} + +// UpdateGroup handles PATCH /groups/{id} requests. +func (h *OgentHandler) UpdateGroup(ctx context.Context, req *UpdateGroupReq, params UpdateGroupParams) (UpdateGroupRes, error) { + b := h.client.Group.UpdateOneID(params.ID) + // Add all fields. + if v, ok := req.Name.Get(); ok { + b.SetName(v) + } + // Add all edges. + if req.Users != nil { + b.ClearUsers().AddUserIDs(req.Users...) + } + // 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.Group.Query().Where(group.ID(e.ID)) + e, err = q.Only(ctx) + if err != nil { + // This should never happen. + return nil, err + } + return NewGroupUpdate(e), nil +} + +// DeleteGroup handles DELETE /groups/{id} requests. +func (h *OgentHandler) DeleteGroup(ctx context.Context, params DeleteGroupParams) (DeleteGroupRes, error) { + err := h.client.Group.DeleteOneID(params.ID).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(DeleteGroupNoContent), nil + +} + +// ListGroup handles GET /groups requests. +func (h *OgentHandler) ListGroup(ctx context.Context, params ListGroupParams) (ListGroupRes, error) { + q := h.client.Group.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 := NewGroupLists(es) + return (*ListGroupOKApplicationJSON)(&r), nil +} + +// ListGroupUsers handles GET /groups/{id}/users requests. +func (h *OgentHandler) ListGroupUsers(ctx context.Context, params ListGroupUsersParams) (ListGroupUsersRes, error) { + q := h.client.Group.Query().Where(group.IDEQ(params.ID)).QueryUsers() + 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 := NewGroupUsersLists(es) + return (*ListGroupUsersOKApplicationJSON)(&r), nil +} + +// CreateUser handles POST /users requests. +func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (CreateUserRes, error) { + b := h.client.User.Create() + // Add all fields. + b.SetUsername(req.Username) + if v, ok := req.CreatedAt.Get(); ok { + b.SetCreatedAt(v) + } + if v, ok := req.UpdatedAt.Get(); ok { + b.SetUpdatedAt(v) + } + if v, ok := req.Next.Get(); ok { + b.SetNext(v) + } + // Add all edges. + b.AddCardIDs(req.Card...) + // 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.User.Query().Where(user.ID(e.ID)) + e, err = q.Only(ctx) + if err != nil { + // This should never happen. + return nil, err + } + return NewUserCreate(e), nil +} + +// ReadUser handles GET /users/{id} requests. +func (h *OgentHandler) ReadUser(ctx context.Context, params ReadUserParams) (ReadUserRes, error) { + q := h.client.User.Query().Where(user.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 NewUserRead(e), nil +} + +// UpdateUser handles PATCH /users/{id} requests. +func (h *OgentHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, params UpdateUserParams) (UpdateUserRes, error) { + b := h.client.User.UpdateOneID(params.ID) + // Add all fields. + if v, ok := req.UpdatedAt.Get(); ok { + b.SetUpdatedAt(v) + } + if v, ok := req.Next.Get(); ok { + b.SetNext(v) + } + // Add all edges. + if req.Card != nil { + b.ClearCard().AddCardIDs(req.Card...) + } + // 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.User.Query().Where(user.ID(e.ID)) + e, err = q.Only(ctx) + if err != nil { + // This should never happen. + return nil, err + } + return NewUserUpdate(e), nil +} + +// DeleteUser handles DELETE /users/{id} requests. +func (h *OgentHandler) DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error) { + err := h.client.User.DeleteOneID(params.ID).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(DeleteUserNoContent), nil + +} + +// ListUser handles GET /users requests. +func (h *OgentHandler) ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error) { + q := h.client.User.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 := NewUserLists(es) + return (*ListUserOKApplicationJSON)(&r), nil +} + +// ListUserCard handles GET /users/{id}/card requests. +func (h *OgentHandler) ListUserCard(ctx context.Context, params ListUserCardParams) (ListUserCardRes, error) { + q := h.client.User.Query().Where(user.IDEQ(params.ID)).QueryCard() + 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 := NewUserCardLists(es) + return (*ListUserCardOKApplicationJSON)(&r), nil } diff --git a/ent/ogent/responses.go b/ent/ogent/responses.go index 80b766c..cc98cf1 100644 --- a/ent/ogent/responses.go +++ b/ent/ogent/responses.go @@ -1,185 +1,463 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package ogent import "t/ent" -func NewUsersCreate(e *ent.Users) *UsersCreate { +func NewCardCreate(e *ent.Card) *CardCreate { if e == nil { return nil } - return &UsersCreate{ - ID: e.ID, - User: e.User, - Chara: NewOptString(e.Chara), - Skill: NewOptInt(e.Skill), - Hp: NewOptInt(e.Hp), - Attack: NewOptInt(e.Attack), - Defense: NewOptInt(e.Defense), - Critical: NewOptInt(e.Critical), - Battle: NewOptInt(e.Battle), - Win: NewOptInt(e.Win), - Day: NewOptInt(e.Day), - Percentage: NewOptFloat64(e.Percentage), - Limit: NewOptBool(e.Limit), - Status: NewOptString(e.Status), - Comment: NewOptString(e.Comment), - CreatedAt: NewOptDateTime(e.CreatedAt), - Next: NewOptString(e.Next), - UpdatedAt: NewOptDateTime(e.UpdatedAt), - URL: NewOptString(e.URL), - } + var ret CardCreate + ret.ID = e.ID + ret.Card = NewOptInt(e.Card) + ret.Status = NewOptString(e.Status) + ret.Cp = NewOptInt(e.Cp) + ret.URL = NewOptString(e.URL) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + return &ret } -func NewUsersCreates(es []*ent.Users) []UsersCreate { +func NewCardCreates(es []*ent.Card) []CardCreate { if len(es) == 0 { return nil } - r := make([]UsersCreate, len(es)) + r := make([]CardCreate, len(es)) for i, e := range es { - r[i] = NewUsersCreate(e).Elem() + r[i] = NewCardCreate(e).Elem() } return r } -func (u *UsersCreate) Elem() UsersCreate { - if u != nil { - return UsersCreate{} +func (c *CardCreate) Elem() CardCreate { + if c == nil { + return CardCreate{} } - return *u + return *c } -func NewUsersList(e *ent.Users) *UsersList { +func NewCardList(e *ent.Card) *CardList { if e == nil { return nil } - return &UsersList{ - ID: e.ID, - User: e.User, - Chara: NewOptString(e.Chara), - Skill: NewOptInt(e.Skill), - Hp: NewOptInt(e.Hp), - Attack: NewOptInt(e.Attack), - Defense: NewOptInt(e.Defense), - Critical: NewOptInt(e.Critical), - Battle: NewOptInt(e.Battle), - Win: NewOptInt(e.Win), - Day: NewOptInt(e.Day), - Percentage: NewOptFloat64(e.Percentage), - Limit: NewOptBool(e.Limit), - Status: NewOptString(e.Status), - Comment: NewOptString(e.Comment), - CreatedAt: NewOptDateTime(e.CreatedAt), - Next: NewOptString(e.Next), - UpdatedAt: NewOptDateTime(e.UpdatedAt), - URL: NewOptString(e.URL), - } + var ret CardList + ret.ID = e.ID + ret.Card = NewOptInt(e.Card) + ret.Status = NewOptString(e.Status) + ret.Cp = NewOptInt(e.Cp) + ret.URL = NewOptString(e.URL) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + return &ret } -func NewUsersLists(es []*ent.Users) []UsersList { +func NewCardLists(es []*ent.Card) []CardList { if len(es) == 0 { return nil } - r := make([]UsersList, len(es)) + r := make([]CardList, len(es)) for i, e := range es { - r[i] = NewUsersList(e).Elem() + r[i] = NewCardList(e).Elem() } return r } -func (u *UsersList) Elem() UsersList { - if u != nil { - return UsersList{} +func (c *CardList) Elem() CardList { + if c == nil { + return CardList{} } - return *u + return *c } -func NewUsersRead(e *ent.Users) *UsersRead { +func NewCardRead(e *ent.Card) *CardRead { if e == nil { return nil } - return &UsersRead{ - ID: e.ID, - User: e.User, - Chara: NewOptString(e.Chara), - Skill: NewOptInt(e.Skill), - Hp: NewOptInt(e.Hp), - Attack: NewOptInt(e.Attack), - Defense: NewOptInt(e.Defense), - Critical: NewOptInt(e.Critical), - Battle: NewOptInt(e.Battle), - Win: NewOptInt(e.Win), - Day: NewOptInt(e.Day), - Percentage: NewOptFloat64(e.Percentage), - Limit: NewOptBool(e.Limit), - Status: NewOptString(e.Status), - Comment: NewOptString(e.Comment), - CreatedAt: NewOptDateTime(e.CreatedAt), - Next: NewOptString(e.Next), - UpdatedAt: NewOptDateTime(e.UpdatedAt), - URL: NewOptString(e.URL), - } + var ret CardRead + ret.ID = e.ID + ret.Card = NewOptInt(e.Card) + ret.Status = NewOptString(e.Status) + ret.Cp = NewOptInt(e.Cp) + ret.URL = NewOptString(e.URL) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + return &ret } -func NewUsersReads(es []*ent.Users) []UsersRead { +func NewCardReads(es []*ent.Card) []CardRead { if len(es) == 0 { return nil } - r := make([]UsersRead, len(es)) + r := make([]CardRead, len(es)) for i, e := range es { - r[i] = NewUsersRead(e).Elem() + r[i] = NewCardRead(e).Elem() } return r } -func (u *UsersRead) Elem() UsersRead { - if u != nil { - return UsersRead{} +func (c *CardRead) Elem() CardRead { + if c == nil { + return CardRead{} } - return *u + return *c } -func NewUsersUpdate(e *ent.Users) *UsersUpdate { +func NewCardUpdate(e *ent.Card) *CardUpdate { if e == nil { return nil } - return &UsersUpdate{ - ID: e.ID, - User: e.User, - Chara: NewOptString(e.Chara), - Skill: NewOptInt(e.Skill), - Hp: NewOptInt(e.Hp), - Attack: NewOptInt(e.Attack), - Defense: NewOptInt(e.Defense), - Critical: NewOptInt(e.Critical), - Battle: NewOptInt(e.Battle), - Win: NewOptInt(e.Win), - Day: NewOptInt(e.Day), - Percentage: NewOptFloat64(e.Percentage), - Limit: NewOptBool(e.Limit), - Status: NewOptString(e.Status), - Comment: NewOptString(e.Comment), - CreatedAt: NewOptDateTime(e.CreatedAt), - Next: NewOptString(e.Next), - UpdatedAt: NewOptDateTime(e.UpdatedAt), - URL: NewOptString(e.URL), - } + var ret CardUpdate + ret.ID = e.ID + ret.Card = NewOptInt(e.Card) + ret.Status = NewOptString(e.Status) + ret.Cp = NewOptInt(e.Cp) + ret.URL = NewOptString(e.URL) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + return &ret } -func NewUsersUpdates(es []*ent.Users) []UsersUpdate { +func NewCardUpdates(es []*ent.Card) []CardUpdate { if len(es) == 0 { return nil } - r := make([]UsersUpdate, len(es)) + r := make([]CardUpdate, len(es)) for i, e := range es { - r[i] = NewUsersUpdate(e).Elem() + r[i] = NewCardUpdate(e).Elem() } return r } -func (u *UsersUpdate) Elem() UsersUpdate { - if u != nil { - return UsersUpdate{} +func (c *CardUpdate) Elem() CardUpdate { + if c == nil { + return CardUpdate{} + } + return *c +} + +func NewCardOwnerRead(e *ent.User) *CardOwnerRead { + if e == nil { + return nil + } + var ret CardOwnerRead + ret.ID = e.ID + ret.Username = e.Username + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.Next = NewOptString(e.Next) + return &ret +} + +func NewCardOwnerReads(es []*ent.User) []CardOwnerRead { + if len(es) == 0 { + return nil + } + r := make([]CardOwnerRead, len(es)) + for i, e := range es { + r[i] = NewCardOwnerRead(e).Elem() + } + return r +} + +func (u *CardOwnerRead) Elem() CardOwnerRead { + if u == nil { + return CardOwnerRead{} } return *u } + +func NewGroupCreate(e *ent.Group) *GroupCreate { + if e == nil { + return nil + } + var ret GroupCreate + ret.ID = e.ID + ret.Name = e.Name + return &ret +} + +func NewGroupCreates(es []*ent.Group) []GroupCreate { + if len(es) == 0 { + return nil + } + r := make([]GroupCreate, len(es)) + for i, e := range es { + r[i] = NewGroupCreate(e).Elem() + } + return r +} + +func (gr *GroupCreate) Elem() GroupCreate { + if gr == nil { + return GroupCreate{} + } + return *gr +} + +func NewGroupList(e *ent.Group) *GroupList { + if e == nil { + return nil + } + var ret GroupList + ret.ID = e.ID + ret.Name = e.Name + return &ret +} + +func NewGroupLists(es []*ent.Group) []GroupList { + if len(es) == 0 { + return nil + } + r := make([]GroupList, len(es)) + for i, e := range es { + r[i] = NewGroupList(e).Elem() + } + return r +} + +func (gr *GroupList) Elem() GroupList { + if gr == nil { + return GroupList{} + } + return *gr +} + +func NewGroupRead(e *ent.Group) *GroupRead { + if e == nil { + return nil + } + var ret GroupRead + ret.ID = e.ID + ret.Name = e.Name + return &ret +} + +func NewGroupReads(es []*ent.Group) []GroupRead { + if len(es) == 0 { + return nil + } + r := make([]GroupRead, len(es)) + for i, e := range es { + r[i] = NewGroupRead(e).Elem() + } + return r +} + +func (gr *GroupRead) Elem() GroupRead { + if gr == nil { + return GroupRead{} + } + return *gr +} + +func NewGroupUpdate(e *ent.Group) *GroupUpdate { + if e == nil { + return nil + } + var ret GroupUpdate + ret.ID = e.ID + ret.Name = e.Name + return &ret +} + +func NewGroupUpdates(es []*ent.Group) []GroupUpdate { + if len(es) == 0 { + return nil + } + r := make([]GroupUpdate, len(es)) + for i, e := range es { + r[i] = NewGroupUpdate(e).Elem() + } + return r +} + +func (gr *GroupUpdate) Elem() GroupUpdate { + if gr == nil { + return GroupUpdate{} + } + return *gr +} + +func NewGroupUsersList(e *ent.User) *GroupUsersList { + if e == nil { + return nil + } + var ret GroupUsersList + ret.ID = e.ID + ret.Username = e.Username + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.Next = NewOptString(e.Next) + return &ret +} + +func NewGroupUsersLists(es []*ent.User) []GroupUsersList { + if len(es) == 0 { + return nil + } + r := make([]GroupUsersList, len(es)) + for i, e := range es { + r[i] = NewGroupUsersList(e).Elem() + } + return r +} + +func (u *GroupUsersList) Elem() GroupUsersList { + if u == nil { + return GroupUsersList{} + } + return *u +} + +func NewUserCreate(e *ent.User) *UserCreate { + if e == nil { + return nil + } + var ret UserCreate + ret.ID = e.ID + ret.Username = e.Username + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.Next = NewOptString(e.Next) + return &ret +} + +func NewUserCreates(es []*ent.User) []UserCreate { + if len(es) == 0 { + return nil + } + r := make([]UserCreate, len(es)) + for i, e := range es { + r[i] = NewUserCreate(e).Elem() + } + return r +} + +func (u *UserCreate) Elem() UserCreate { + if u == nil { + return UserCreate{} + } + return *u +} + +func NewUserList(e *ent.User) *UserList { + if e == nil { + return nil + } + var ret UserList + ret.ID = e.ID + ret.Username = e.Username + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.Next = NewOptString(e.Next) + return &ret +} + +func NewUserLists(es []*ent.User) []UserList { + if len(es) == 0 { + return nil + } + r := make([]UserList, len(es)) + for i, e := range es { + r[i] = NewUserList(e).Elem() + } + return r +} + +func (u *UserList) Elem() UserList { + if u == nil { + return UserList{} + } + return *u +} + +func NewUserRead(e *ent.User) *UserRead { + if e == nil { + return nil + } + var ret UserRead + ret.ID = e.ID + ret.Username = e.Username + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.Next = NewOptString(e.Next) + return &ret +} + +func NewUserReads(es []*ent.User) []UserRead { + if len(es) == 0 { + return nil + } + r := make([]UserRead, len(es)) + for i, e := range es { + r[i] = NewUserRead(e).Elem() + } + return r +} + +func (u *UserRead) Elem() UserRead { + if u == nil { + return UserRead{} + } + return *u +} + +func NewUserUpdate(e *ent.User) *UserUpdate { + if e == nil { + return nil + } + var ret UserUpdate + ret.ID = e.ID + ret.Username = e.Username + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.Next = NewOptString(e.Next) + return &ret +} + +func NewUserUpdates(es []*ent.User) []UserUpdate { + if len(es) == 0 { + return nil + } + r := make([]UserUpdate, len(es)) + for i, e := range es { + r[i] = NewUserUpdate(e).Elem() + } + return r +} + +func (u *UserUpdate) Elem() UserUpdate { + if u == nil { + return UserUpdate{} + } + return *u +} + +func NewUserCardList(e *ent.Card) *UserCardList { + if e == nil { + return nil + } + var ret UserCardList + ret.ID = e.ID + ret.Card = NewOptInt(e.Card) + ret.Status = NewOptString(e.Status) + ret.Cp = NewOptInt(e.Cp) + ret.URL = NewOptString(e.URL) + ret.CreatedAt = NewOptDateTime(e.CreatedAt) + return &ret +} + +func NewUserCardLists(es []*ent.Card) []UserCardList { + if len(es) == 0 { + return nil + } + r := make([]UserCardList, len(es)) + for i, e := range es { + r[i] = NewUserCardList(e).Elem() + } + return r +} + +func (c *UserCardList) Elem() UserCardList { + if c == nil { + return UserCardList{} + } + return *c +} diff --git a/ent/openapi.json b/ent/openapi.json index 76222fb..5e560df 100644 --- a/ent/openapi.json +++ b/ent/openapi.json @@ -6,15 +6,951 @@ "version": "0.1.0" }, "paths": { + "/cards": { + "get": { + "tags": [ + "Card" + ], + "summary": "List Cards", + "description": "List Cards.", + "operationId": "listCard", + "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": 255, + "minimum": 1 + } + } + ], + "responses": { + "200": { + "description": "result Card list", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/CardList" + } + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "post": { + "tags": [ + "Card" + ], + "summary": "Create a new Card", + "description": "Creates a new Card and persists it to storage.", + "operationId": "createCard", + "requestBody": { + "description": "Card to create", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "card": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "cp": { + "type": "integer" + }, + "url": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "owner": { + "type": "integer" + } + }, + "required": [ + "owner" + ] + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "Card created", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CardCreate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/cards/{id}": { + "get": { + "tags": [ + "Card" + ], + "summary": "Find a Card by ID", + "description": "Finds the Card with the requested ID and returns it.", + "operationId": "readCard", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Card", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "Card with requested ID was found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CardRead" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "delete": { + "tags": [ + "Card" + ], + "summary": "Deletes a Card by ID", + "description": "Deletes the Card with the requested ID.", + "operationId": "deleteCard", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Card", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "204": { + "description": "Card 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": [ + "Card" + ], + "summary": "Updates a Card", + "description": "Updates a Card and persists changes to storage.", + "operationId": "updateCard", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Card", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "requestBody": { + "description": "Card properties to update", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "owner": { + "type": "integer" + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "Card updated", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CardUpdate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/cards/{id}/d": { + "description": "Start an draw as done", + "put": { + "tags": [ + "Card" + ], + "summary": "Draws a card item as done.", + "operationId": "drawDone", + "responses": { + "204": { + "description": "Item marked as done" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "schema": { + "type": "integer" + } + } + ] + }, + "/cards/{id}/owner": { + "get": { + "tags": [ + "Card" + ], + "summary": "Find the attached User", + "description": "Find the attached User of the Card with the given ID", + "operationId": "readCardOwner", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Card", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "User attached to Card with requested ID was found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Card_OwnerRead" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/groups": { + "get": { + "tags": [ + "Group" + ], + "summary": "List Groups", + "description": "List Groups.", + "operationId": "listGroup", + "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": 255, + "minimum": 1 + } + } + ], + "responses": { + "200": { + "description": "result Group list", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/GroupList" + } + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "post": { + "tags": [ + "Group" + ], + "summary": "Create a new Group", + "description": "Creates a new Group and persists it to storage.", + "operationId": "createGroup", + "requestBody": { + "description": "Group to create", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "users": { + "type": "array", + "items": { + "type": "integer" + } + } + }, + "required": [ + "name" + ] + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "Group created", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/GroupCreate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/groups/{id}": { + "get": { + "tags": [ + "Group" + ], + "summary": "Find a Group by ID", + "description": "Finds the Group with the requested ID and returns it.", + "operationId": "readGroup", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Group", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "Group with requested ID was found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/GroupRead" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "delete": { + "tags": [ + "Group" + ], + "summary": "Deletes a Group by ID", + "description": "Deletes the Group with the requested ID.", + "operationId": "deleteGroup", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Group", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "204": { + "description": "Group 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": [ + "Group" + ], + "summary": "Updates a Group", + "description": "Updates a Group and persists changes to storage.", + "operationId": "updateGroup", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Group", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "requestBody": { + "description": "Group properties to update", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "users": { + "type": "array", + "items": { + "type": "integer" + } + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "Group updated", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/GroupUpdate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/groups/{id}/users": { + "get": { + "tags": [ + "Group" + ], + "summary": "List attached Users", + "description": "List attached Users.", + "operationId": "listGroupUsers", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the Group", + "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 Groups list", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Group_UsersList" + } + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, "/users": { "get": { "tags": [ - "Users" + "User" ], "summary": "List Users", "description": "List Users.", - "operationId": "listUsers", + "operationId": "listUser", "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": 255, + "minimum": 1 + } + } + ], + "responses": { + "200": { + "description": "result User list", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/UserList" + } + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "post": { + "tags": [ + "User" + ], + "summary": "Create a new User", + "description": "Creates a new User and persists it to storage.", + "operationId": "createUser", + "requestBody": { + "description": "User to create", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "username": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "next": { + "type": "string" + }, + "card": { + "type": "array", + "items": { + "type": "integer" + } + } + }, + "required": [ + "username" + ] + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "User created", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UserCreate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/users/{id}": { + "get": { + "tags": [ + "User" + ], + "summary": "Find a User by ID", + "description": "Finds the User with the requested ID and returns it.", + "operationId": "readUser", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the User", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "User with requested ID was found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UserRead" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "delete": { + "tags": [ + "User" + ], + "summary": "Deletes a User by ID", + "description": "Deletes the User with the requested ID.", + "operationId": "deleteUser", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the User", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "204": { + "description": "User 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": [ + "User" + ], + "summary": "Updates a User", + "description": "Updates a User and persists changes to storage.", + "operationId": "updateUser", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the User", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "requestBody": { + "description": "User properties to update", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "updated_at": { + "type": "string", + "format": "date-time" + }, + "next": { + "type": "string" + }, + "card": { + "type": "array", + "items": { + "type": "integer" + } + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "User updated", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UserUpdate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/users/{id}/card": { + "get": { + "tags": [ + "User" + ], + "summary": "List attached Cards", + "description": "List attached Cards.", + "operationId": "listUserCard", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the User", + "required": true, + "schema": { + "type": "integer" + } + }, { "name": "page", "in": "query", @@ -40,7 +976,7 @@ "schema": { "type": "array", "items": { - "$ref": "#/components/schemas/UsersList" + "$ref": "#/components/schemas/User_CardList" } } } @@ -59,315 +995,13 @@ "$ref": "#/components/responses/500" } } - }, - "post": { - "tags": [ - "Users" - ], - "summary": "Create a new Users", - "description": "Creates a new Users and persists it to storage.", - "operationId": "createUsers", - "requestBody": { - "description": "Users to create", - "content": { - "application/json": { - "schema": { - "type": "object", - "properties": { - "user": { - "type": "string" - }, - "chara": { - "type": "string" - }, - "skill": { - "type": "integer" - }, - "hp": { - "type": "integer" - }, - "attack": { - "type": "integer" - }, - "defense": { - "type": "integer" - }, - "critical": { - "type": "integer" - }, - "battle": { - "type": "integer" - }, - "win": { - "type": "integer" - }, - "day": { - "type": "integer" - }, - "percentage": { - "type": "number", - "format": "double" - }, - "limit": { - "type": "boolean" - }, - "status": { - "type": "string" - }, - "comment": { - "type": "string" - }, - "created_at": { - "type": "string", - "format": "date-time" - }, - "next": { - "type": "string" - }, - "updated_at": { - "type": "string", - "format": "date-time" - }, - "url": { - "type": "string" - } - }, - "required": [ - "user" - ] - } - } - }, - "required": true - }, - "responses": { - "200": { - "description": "Users created", - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/UsersCreate" - } - } - } - }, - "400": { - "$ref": "#/components/responses/400" - }, - "409": { - "$ref": "#/components/responses/409" - }, - "500": { - "$ref": "#/components/responses/500" - } - } - } - }, - "/users/{id}": { - "get": { - "tags": [ - "Users" - ], - "summary": "Find a Users by ID", - "description": "Finds the Users with the requested ID and returns it.", - "operationId": "readUsers", - "parameters": [ - { - "name": "id", - "in": "path", - "description": "ID of the Users", - "schema": { - "type": "integer" - }, - "required": true - } - ], - "responses": { - "200": { - "description": "Users with requested ID was found", - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/UsersRead" - } - } - } - }, - "400": { - "$ref": "#/components/responses/400" - }, - "404": { - "$ref": "#/components/responses/404" - }, - "409": { - "$ref": "#/components/responses/409" - }, - "500": { - "$ref": "#/components/responses/500" - } - } - }, - "delete": { - "tags": [ - "Users" - ], - "summary": "Deletes a Users by ID", - "description": "Deletes the Users with the requested ID.", - "operationId": "deleteUsers", - "parameters": [ - { - "name": "id", - "in": "path", - "description": "ID of the Users", - "schema": { - "type": "integer" - }, - "required": true - } - ], - "responses": { - "204": { - "description": "Users 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": [ - "Users" - ], - "summary": "Updates a Users", - "description": "Updates a Users and persists changes to storage.", - "operationId": "updateUsers", - "parameters": [ - { - "name": "id", - "in": "path", - "description": "ID of the Users", - "schema": { - "type": "integer" - }, - "required": true - } - ], - "requestBody": { - "description": "Users properties to update", - "content": { - "application/json": { - "schema": { - "type": "object", - "properties": { - "hp": { - "type": "integer" - }, - "attack": { - "type": "integer" - }, - "defense": { - "type": "integer" - }, - "critical": { - "type": "integer" - }, - "battle": { - "type": "integer" - }, - "win": { - "type": "integer" - }, - "day": { - "type": "integer" - }, - "percentage": { - "type": "number", - "format": "double" - }, - "limit": { - "type": "boolean" - }, - "comment": { - "type": "string" - }, - "next": { - "type": "string" - }, - "updated_at": { - "type": "string", - "format": "date-time" - } - } - } - } - }, - "required": true - }, - "responses": { - "200": { - "description": "Users updated", - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/UsersUpdate" - } - } - } - }, - "400": { - "$ref": "#/components/responses/400" - }, - "404": { - "$ref": "#/components/responses/404" - }, - "409": { - "$ref": "#/components/responses/409" - }, - "500": { - "$ref": "#/components/responses/500" - } - } } }, - "/users/{id}/d": { - "description": "Start an draw as done", - "put": { - "tags": [ - "Users" - ], - "summary": "Draws a card item as done.", - "operationId": "drawDone", - "responses": { - "204": { - "description": "Item marked as done" - } - } - }, - "parameters": [ - { - "name": "id", - "in": "path", - "schema": { - "type": "integer" - }, - "required": true - } - ] - }, - "/users/{id}/start": { + "/users/{id}/card/start": { "description": "Start an draw as done", "patch": { "tags": [ - "Users" + "Card" ], "summary": "Draws a card item as done.", "operationId": "drawStart", @@ -381,359 +1015,449 @@ { "name": "id", "in": "path", + "required": true, "schema": { "type": "integer" - }, - "required": true + } } ] } }, "components": { "schemas": { - "Users": { + "Card": { "type": "object", "properties": { "id": { "type": "integer" }, - "user": { - "type": "string" - }, - "chara": { - "type": "string" - }, - "skill": { + "card": { "type": "integer" }, - "hp": { - "type": "integer" - }, - "attack": { - "type": "integer" - }, - "defense": { - "type": "integer" - }, - "critical": { - "type": "integer" - }, - "battle": { - "type": "integer" - }, - "win": { - "type": "integer" - }, - "day": { - "type": "integer" - }, - "percentage": { - "type": "number", - "format": "double" - }, - "limit": { - "type": "boolean" - }, "status": { "type": "string" }, - "comment": { + "cp": { + "type": "integer" + }, + "url": { "type": "string" }, "created_at": { "type": "string", "format": "date-time" }, - "next": { - "type": "string" - }, - "updated_at": { - "type": "string", - "format": "date-time" - }, - "url": { - "type": "string" + "owner": { + "$ref": "#/components/schemas/User" } }, "required": [ "id", - "user" + "owner" ] }, - "UsersCreate": { + "CardCreate": { "type": "object", "properties": { "id": { "type": "integer" }, - "user": { - "type": "string" - }, - "chara": { - "type": "string" - }, - "skill": { + "card": { "type": "integer" }, - "hp": { - "type": "integer" - }, - "attack": { - "type": "integer" - }, - "defense": { - "type": "integer" - }, - "critical": { - "type": "integer" - }, - "battle": { - "type": "integer" - }, - "win": { - "type": "integer" - }, - "day": { - "type": "integer" - }, - "percentage": { - "type": "number", - "format": "double" - }, - "limit": { - "type": "boolean" - }, "status": { "type": "string" }, - "comment": { + "cp": { + "type": "integer" + }, + "url": { "type": "string" }, "created_at": { "type": "string", "format": "date-time" - }, - "next": { - "type": "string" - }, - "updated_at": { - "type": "string", - "format": "date-time" - }, - "url": { - "type": "string" } }, "required": [ - "id", - "user" + "id" ] }, - "UsersList": { + "CardList": { "type": "object", "properties": { "id": { "type": "integer" }, - "user": { - "type": "string" - }, - "chara": { - "type": "string" - }, - "skill": { + "card": { "type": "integer" }, - "hp": { - "type": "integer" - }, - "attack": { - "type": "integer" - }, - "defense": { - "type": "integer" - }, - "critical": { - "type": "integer" - }, - "battle": { - "type": "integer" - }, - "win": { - "type": "integer" - }, - "day": { - "type": "integer" - }, - "percentage": { - "type": "number", - "format": "double" - }, - "limit": { - "type": "boolean" - }, "status": { "type": "string" }, - "comment": { + "cp": { + "type": "integer" + }, + "url": { "type": "string" }, "created_at": { "type": "string", "format": "date-time" - }, - "next": { - "type": "string" - }, - "updated_at": { - "type": "string", - "format": "date-time" - }, - "url": { - "type": "string" } }, "required": [ - "id", - "user" + "id" ] }, - "UsersRead": { + "CardRead": { "type": "object", "properties": { "id": { "type": "integer" }, - "user": { - "type": "string" - }, - "chara": { - "type": "string" - }, - "skill": { + "card": { "type": "integer" }, - "hp": { - "type": "integer" - }, - "attack": { - "type": "integer" - }, - "defense": { - "type": "integer" - }, - "critical": { - "type": "integer" - }, - "battle": { - "type": "integer" - }, - "win": { - "type": "integer" - }, - "day": { - "type": "integer" - }, - "percentage": { - "type": "number", - "format": "double" - }, - "limit": { - "type": "boolean" - }, "status": { "type": "string" }, - "comment": { + "cp": { + "type": "integer" + }, + "url": { "type": "string" }, "created_at": { "type": "string", "format": "date-time" - }, - "next": { - "type": "string" - }, - "updated_at": { - "type": "string", - "format": "date-time" - }, - "url": { - "type": "string" } }, "required": [ - "id", - "user" + "id" ] }, - "UsersUpdate": { + "CardUpdate": { "type": "object", "properties": { "id": { "type": "integer" }, - "user": { - "type": "string" - }, - "chara": { - "type": "string" - }, - "skill": { + "card": { "type": "integer" }, - "hp": { - "type": "integer" - }, - "attack": { - "type": "integer" - }, - "defense": { - "type": "integer" - }, - "critical": { - "type": "integer" - }, - "battle": { - "type": "integer" - }, - "win": { - "type": "integer" - }, - "day": { - "type": "integer" - }, - "percentage": { - "type": "number", - "format": "double" - }, - "limit": { - "type": "boolean" - }, "status": { "type": "string" }, - "comment": { + "cp": { + "type": "integer" + }, + "url": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id" + ] + }, + "Card_OwnerRead": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "username": { "type": "string" }, "created_at": { "type": "string", "format": "date-time" }, - "next": { - "type": "string" - }, "updated_at": { "type": "string", "format": "date-time" }, - "url": { + "next": { "type": "string" } }, "required": [ "id", - "user" + "username" + ] + }, + "Group": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + }, + "users": { + "type": "array", + "items": { + "$ref": "#/components/schemas/User" + } + } + }, + "required": [ + "id", + "name" + ] + }, + "GroupCreate": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + } + }, + "required": [ + "id", + "name" + ] + }, + "GroupList": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + } + }, + "required": [ + "id", + "name" + ] + }, + "GroupRead": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + } + }, + "required": [ + "id", + "name" + ] + }, + "GroupUpdate": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + } + }, + "required": [ + "id", + "name" + ] + }, + "Group_UsersList": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "username": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "next": { + "type": "string" + } + }, + "required": [ + "id", + "username" + ] + }, + "User": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "username": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "next": { + "type": "string" + }, + "card": { + "type": "array", + "items": { + "$ref": "#/components/schemas/Card" + } + } + }, + "required": [ + "id", + "username" + ] + }, + "UserCreate": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "username": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "next": { + "type": "string" + } + }, + "required": [ + "id", + "username" + ] + }, + "UserList": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "username": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "next": { + "type": "string" + } + }, + "required": [ + "id", + "username" + ] + }, + "UserRead": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "username": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "next": { + "type": "string" + } + }, + "required": [ + "id", + "username" + ] + }, + "UserUpdate": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "username": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "updated_at": { + "type": "string", + "format": "date-time" + }, + "next": { + "type": "string" + } + }, + "required": [ + "id", + "username" + ] + }, + "User_CardList": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "card": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "cp": { + "type": "integer" + }, + "url": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id" ] } }, diff --git a/ent/predicate/predicate.go b/ent/predicate/predicate.go index 2aa82af..62c2877 100644 --- a/ent/predicate/predicate.go +++ b/ent/predicate/predicate.go @@ -1,4 +1,4 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package predicate @@ -6,5 +6,11 @@ import ( "entgo.io/ent/dialect/sql" ) -// Users is the predicate function for users builders. -type Users func(*sql.Selector) +// Card is the predicate function for card builders. +type Card func(*sql.Selector) + +// Group is the predicate function for group builders. +type Group func(*sql.Selector) + +// User is the predicate function for user builders. +type User func(*sql.Selector) diff --git a/ent/runtime.go b/ent/runtime.go index 56c94a7..ee12d7e 100644 --- a/ent/runtime.go +++ b/ent/runtime.go @@ -1,10 +1,11 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package ent import ( + "t/ent/card" "t/ent/schema" - "t/ent/users" + "t/ent/user" "time" ) @@ -12,93 +13,58 @@ import ( // (default values, validators, hooks and policies) and stitches it // to their package variables. func init() { - usersFields := schema.Users{}.Fields() - _ = usersFields - // usersDescUser is the schema descriptor for user field. - usersDescUser := usersFields[0].Descriptor() - // users.UserValidator is a validator for the "user" field. It is called by the builders before save. - users.UserValidator = func() func(string) error { - validators := usersDescUser.Validators + cardFields := schema.Card{}.Fields() + _ = cardFields + // cardDescCard is the schema descriptor for card field. + cardDescCard := cardFields[0].Descriptor() + // card.DefaultCard holds the default value on creation for the card field. + card.DefaultCard = cardDescCard.Default.(func() int) + // cardDescStatus is the schema descriptor for status field. + cardDescStatus := cardFields[1].Descriptor() + // card.DefaultStatus holds the default value on creation for the status field. + card.DefaultStatus = cardDescStatus.Default.(func() string) + // cardDescCp is the schema descriptor for cp field. + cardDescCp := cardFields[2].Descriptor() + // card.DefaultCp holds the default value on creation for the cp field. + card.DefaultCp = cardDescCp.Default.(func() int) + // cardDescURL is the schema descriptor for url field. + cardDescURL := cardFields[3].Descriptor() + // card.DefaultURL holds the default value on creation for the url field. + card.DefaultURL = cardDescURL.Default.(string) + // cardDescCreatedAt is the schema descriptor for created_at field. + cardDescCreatedAt := cardFields[4].Descriptor() + // card.DefaultCreatedAt holds the default value on creation for the created_at field. + card.DefaultCreatedAt = cardDescCreatedAt.Default.(func() time.Time) + userFields := schema.User{}.Fields() + _ = userFields + // userDescUsername is the schema descriptor for username field. + userDescUsername := userFields[0].Descriptor() + // user.UsernameValidator is a validator for the "username" field. It is called by the builders before save. + user.UsernameValidator = func() func(string) error { + validators := userDescUsername.Validators fns := [...]func(string) error{ validators[0].(func(string) error), validators[1].(func(string) error), - validators[2].(func(string) error), } - return func(user string) error { + return func(username string) error { for _, fn := range fns { - if err := fn(user); err != nil { + if err := fn(username); err != nil { return err } } return nil } }() - // usersDescChara is the schema descriptor for chara field. - usersDescChara := usersFields[1].Descriptor() - // users.DefaultChara holds the default value on creation for the chara field. - users.DefaultChara = usersDescChara.Default.(string) - // usersDescSkill is the schema descriptor for skill field. - usersDescSkill := usersFields[2].Descriptor() - // users.DefaultSkill holds the default value on creation for the skill field. - users.DefaultSkill = usersDescSkill.Default.(int) - // usersDescHp is the schema descriptor for hp field. - usersDescHp := usersFields[3].Descriptor() - // users.DefaultHp holds the default value on creation for the hp field. - users.DefaultHp = usersDescHp.Default.(int) - // usersDescAttack is the schema descriptor for attack field. - usersDescAttack := usersFields[4].Descriptor() - // users.DefaultAttack holds the default value on creation for the attack field. - users.DefaultAttack = usersDescAttack.Default.(int) - // usersDescDefense is the schema descriptor for defense field. - usersDescDefense := usersFields[5].Descriptor() - // users.DefaultDefense holds the default value on creation for the defense field. - users.DefaultDefense = usersDescDefense.Default.(int) - // usersDescCritical is the schema descriptor for critical field. - usersDescCritical := usersFields[6].Descriptor() - // users.DefaultCritical holds the default value on creation for the critical field. - users.DefaultCritical = usersDescCritical.Default.(int) - // usersDescBattle is the schema descriptor for battle field. - usersDescBattle := usersFields[7].Descriptor() - // users.DefaultBattle holds the default value on creation for the battle field. - users.DefaultBattle = usersDescBattle.Default.(int) - // usersDescWin is the schema descriptor for win field. - usersDescWin := usersFields[8].Descriptor() - // users.DefaultWin holds the default value on creation for the win field. - users.DefaultWin = usersDescWin.Default.(int) - // usersDescDay is the schema descriptor for day field. - usersDescDay := usersFields[9].Descriptor() - // users.DefaultDay holds the default value on creation for the day field. - users.DefaultDay = usersDescDay.Default.(int) - // usersDescPercentage is the schema descriptor for percentage field. - usersDescPercentage := usersFields[10].Descriptor() - // users.DefaultPercentage holds the default value on creation for the percentage field. - users.DefaultPercentage = usersDescPercentage.Default.(float64) - // usersDescLimit is the schema descriptor for limit field. - usersDescLimit := usersFields[11].Descriptor() - // users.DefaultLimit holds the default value on creation for the limit field. - users.DefaultLimit = usersDescLimit.Default.(bool) - // usersDescStatus is the schema descriptor for status field. - usersDescStatus := usersFields[12].Descriptor() - // users.DefaultStatus holds the default value on creation for the status field. - users.DefaultStatus = usersDescStatus.Default.(string) - // usersDescComment is the schema descriptor for comment field. - usersDescComment := usersFields[13].Descriptor() - // users.DefaultComment holds the default value on creation for the comment field. - users.DefaultComment = usersDescComment.Default.(string) - // usersDescCreatedAt is the schema descriptor for created_at field. - usersDescCreatedAt := usersFields[14].Descriptor() - // users.DefaultCreatedAt holds the default value on creation for the created_at field. - users.DefaultCreatedAt = usersDescCreatedAt.Default.(func() time.Time) - // usersDescNext is the schema descriptor for next field. - usersDescNext := usersFields[15].Descriptor() - // users.DefaultNext holds the default value on creation for the next field. - users.DefaultNext = usersDescNext.Default.(string) - // usersDescUpdatedAt is the schema descriptor for updated_at field. - usersDescUpdatedAt := usersFields[16].Descriptor() - // users.DefaultUpdatedAt holds the default value on creation for the updated_at field. - users.DefaultUpdatedAt = usersDescUpdatedAt.Default.(func() time.Time) - // usersDescURL is the schema descriptor for url field. - usersDescURL := usersFields[17].Descriptor() - // users.DefaultURL holds the default value on creation for the url field. - users.DefaultURL = usersDescURL.Default.(string) + // userDescCreatedAt is the schema descriptor for created_at field. + userDescCreatedAt := userFields[1].Descriptor() + // user.DefaultCreatedAt holds the default value on creation for the created_at field. + user.DefaultCreatedAt = userDescCreatedAt.Default.(func() time.Time) + // userDescUpdatedAt is the schema descriptor for updated_at field. + userDescUpdatedAt := userFields[2].Descriptor() + // user.DefaultUpdatedAt holds the default value on creation for the updated_at field. + user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() time.Time) + // userDescNext is the schema descriptor for next field. + userDescNext := userFields[3].Descriptor() + // user.DefaultNext holds the default value on creation for the next field. + user.DefaultNext = userDescNext.Default.(string) } diff --git a/ent/runtime/runtime.go b/ent/runtime/runtime.go index 0bf7c16..ef9df7c 100644 --- a/ent/runtime/runtime.go +++ b/ent/runtime/runtime.go @@ -1,10 +1,10 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package runtime // The schema-stitching logic is generated in t/ent/runtime.go const ( - Version = "v0.10.0" // Version of ent codegen. - Sum = "h1:9cBomE1fh+WX34DPYQL7tDNAIvhKa3tXvwxuLyhYCMo=" // Sum of ent codegen. + Version = "v0.11.9" // Version of ent codegen. + Sum = "h1:dbbCkAiPVTRBIJwoZctiSYjB7zxQIBOzVSU5H9VYIQI=" // Sum of ent codegen. ) diff --git a/ent/schema/card.go b/ent/schema/card.go new file mode 100644 index 0000000..1b2febd --- /dev/null +++ b/ent/schema/card.go @@ -0,0 +1,97 @@ +package schema + +import ( + "time" + "math/rand" + "entgo.io/ent" + "entgo.io/ent/schema/edge" + "entgo.io/ent/schema/field" +) + +// Card holds the schema definition for the Card entity. +type Card struct { + ent.Schema +} +var url = "https://card.syui.ai" + +var card int +var super string +var cp int + +func (Card) Fields() []ent.Field { + return []ent.Field{ + field.Int("card"). + Immutable(). + DefaultFunc(func() int { + rand.Seed(time.Now().UnixNano()) + var a = rand.Intn(10) + if a == 1 { + card = rand.Intn(15) + } else { + card = 0 + } + if card == 13 { + card = 14 + } + return card + }). + Optional(), + + field.String("status"). + Immutable(). + DefaultFunc(func() string { + rand.Seed(time.Now().UnixNano()) + var a = rand.Intn(10) + if a == 1 { + super = "super" + } else { + super = "normal" + } + if card == 0 { + super = "normal" + } + return super + }). + Optional(), + + field.Int("cp"). + Immutable(). + DefaultFunc(func() int { + rand.Seed(time.Now().UnixNano()) + var cp = rand.Intn(100) + if cp == 1 { + cp = rand.Intn(250) + } + if card > 1 { + cp = cp + rand.Intn(250) + } + if super == "super" { + cp = cp + rand.Intn(500) + } + + return cp + }). + Optional(), + + field.String("url"). + Immutable(). + Default(url). + Optional(), + + field.Time("created_at"). + Immutable(). + Optional(). + Default(func() time.Time { + return time.Now().In(jst) + }), + } +} + +func (Card) Edges() []ent.Edge { + return []ent.Edge{ + edge.From("owner", User.Type). + Ref("card"). + Unique(). + Required(), + } +} diff --git a/ent/schema/group.go b/ent/schema/group.go new file mode 100644 index 0000000..941b39a --- /dev/null +++ b/ent/schema/group.go @@ -0,0 +1,35 @@ +package schema + +import ( + "entgo.io/ent" + "entgo.io/ent/schema/edge" + "entgo.io/ent/schema/field" + "entgo.io/ent/schema/index" +) + +// Group holds the schema definition for the Group entity. +type Group struct { + ent.Schema +} + +// Fields of the Group. +func (Group) Fields() []ent.Field { + return []ent.Field{ + field.String("name"), + } +} + +// Edges of the Group. +func (Group) Edges() []ent.Edge { + return []ent.Edge{ + edge.To("users", User.Type), + } +} + +// Indexes of the Group. +func (Group) Indexes() []ent.Index { + return []ent.Index{ + index.Fields("name").Unique(), + } +} + diff --git a/ent/schema/user.go b/ent/schema/user.go new file mode 100644 index 0000000..4022809 --- /dev/null +++ b/ent/schema/user.go @@ -0,0 +1,74 @@ +package schema + +import ( + "time" + //"regexp" + //"math/rand" + "entgo.io/ent" + "entgo.io/ent/schema/edge" + "entgo.io/ent/schema/field" + "entgo.io/ent/schema/index" + //"entgo.io/ent/schema/mixin" +) + +var jst,err = time.LoadLocation("Asia/Tokyo") + +// User holds the schema definition for the User entity. +type User struct { + ent.Schema +} + +func Nextime() (tt string){ + t := time.Now().In(jst) + //t := time.Now().Add(time.Hour * 24 * 1).In(jst) + tt = t.Format("20060102") + return +} + +func (User) Fields() []ent.Field { + return []ent.Field{ + + field.String("username"). + NotEmpty(). + Immutable(). + MaxLen(30). + //Match(regexp.MustCompile("[a-z]+$")). + Unique(), + + //field.Bool("limit"). + //Optional(). + //Default(false), + + field.Time("created_at"). + Immutable(). + Optional(). + Default(func() time.Time { + return time.Now().In(jst) + }), + + field.Time("updated_at"). + Optional(). + Default(func() time.Time { + return time.Now().In(jst) + }), + + field.String("next"). + Default(Nextime()). + Optional(), + + } +} + +// Indexes of the User. +func (User) Indexes() []ent.Index { + return []ent.Index{ + index.Fields("username").Unique(), + } +} + +func (User) Edges() []ent.Edge { + return []ent.Edge{ + edge.To("card", Card.Type), + //Unique(), + } +} diff --git a/ent/schema/users.go b/ent/schema/users.go deleted file mode 100644 index ff29605..0000000 --- a/ent/schema/users.go +++ /dev/null @@ -1,172 +0,0 @@ -package schema - -import ( - "time" - "regexp" - "entgo.io/ent" - "math/rand" - "entgo.io/ent/schema/field" - "github.com/kyokomi/lottery" -) - -type Users struct { - ent.Schema -} - -func Random(i int) (l int){ - rand.Seed(time.Now().UnixNano()) - l = rand.Intn(20) - for l == 0 { - l = rand.Intn(20) - } - return -} - -func Kira(i int) (l bool){ - lot := lottery.New(rand.New(rand.NewSource(time.Now().UnixNano()))) - if lot.Lot(i) { - l = true - } else { - l = false - } - return -} - -var jst,err = time.LoadLocation("Asia/Tokyo") - -var a = Random(4) -var d = Random(20) -var h = Random(20) -var k = Random(20) -var s = Random(20) -var c = Random(20) -var battle = 2 - -func StatusR()(status string){ - if d == 1 { - var status = "super" - return status - } else { - var status = "normal" - return status - } - return -} - -func CharaR()(chara string){ -if a == 1 { - var chara = "drai" -return chara -} else if a == 2 { - var chara = "octkat" -return chara -} else if a == 3 { - var chara = "kyosuke" -return chara -} else { - var chara = "ponta" -return chara -} -return -} - -func Nextime() (tt string){ - t := time.Now().Add(time.Hour * 24 * 1).In(jst) - tt = t.Format("20060102") - return -} - -func (Users) Fields() []ent.Field { - return []ent.Field{ - - field.String("user"). - NotEmpty(). - Immutable(). - MaxLen(7). - Match(regexp.MustCompile("[a-z]+$")). - Unique(), - - field.String("chara"). - Immutable(). - Default(CharaR()). - Optional(), - - field.Int("skill"). - Immutable(). - Optional(). - Default(k), - - field.Int("hp"). - Optional(). - Default(h), - - field.Int("attack"). - Optional(). - Default(a), - - field.Int("defense"). - Optional(). - Default(d), - - field.Int("critical"). - Optional(). - Default(c), - - field.Int("battle"). - Optional(). - Default(1), - - field.Int("win"). - Optional(). - Default(0), - - field.Int("day"). - Optional(). - Default(0), - - field.Float("percentage"). - Optional(). - Default(0), - - field.Bool("limit"). - Optional(). - Default(false), - - field.String("status"). - Immutable(). - Optional(). - Default(StatusR()), - - field.String("comment"). - Optional(). - Default(""), - - field.Time("created_at"). - Immutable(). - Optional(). - Default(func() time.Time { - return time.Now().In(jst) - }), - - field.String("next"). - Default(Nextime()). - Optional(), - - field.Time("updated_at"). - Optional(). - Default(func() time.Time { - return time.Now().In(jst) - }), - - field.String("url"). - Immutable(). - Optional(). - Default("https://syui.cf/api"), - } - -} - -func (Users) Edges() []ent.Edge { - return []ent.Edge{} -} - diff --git a/ent/tx.go b/ent/tx.go index 276923f..598fb90 100644 --- a/ent/tx.go +++ b/ent/tx.go @@ -1,4 +1,4 @@ -// Code generated by entc, DO NOT EDIT. +// Code generated by ent, DO NOT EDIT. package ent @@ -12,18 +12,16 @@ import ( // Tx is a transactional client that is created by calling Client.Tx(). type Tx struct { config - // Users is the client for interacting with the Users builders. - Users *UsersClient + // Card is the client for interacting with the Card builders. + Card *CardClient + // Group is the client for interacting with the Group builders. + Group *GroupClient + // User is the client for interacting with the User builders. + User *UserClient // lazily loaded. client *Client clientOnce sync.Once - - // completion callbacks. - mu sync.Mutex - onCommit []CommitHook - onRollback []RollbackHook - // ctx lives for the life of the transaction. It is // the same context used by the underlying connection. ctx context.Context @@ -68,9 +66,9 @@ func (tx *Tx) Commit() error { var fn Committer = CommitFunc(func(context.Context, *Tx) error { return txDriver.tx.Commit() }) - tx.mu.Lock() - hooks := append([]CommitHook(nil), tx.onCommit...) - tx.mu.Unlock() + txDriver.mu.Lock() + hooks := append([]CommitHook(nil), txDriver.onCommit...) + txDriver.mu.Unlock() for i := len(hooks) - 1; i >= 0; i-- { fn = hooks[i](fn) } @@ -79,9 +77,10 @@ func (tx *Tx) Commit() error { // OnCommit adds a hook to call on commit. func (tx *Tx) OnCommit(f CommitHook) { - tx.mu.Lock() - defer tx.mu.Unlock() - tx.onCommit = append(tx.onCommit, f) + txDriver := tx.config.driver.(*txDriver) + txDriver.mu.Lock() + txDriver.onCommit = append(txDriver.onCommit, f) + txDriver.mu.Unlock() } type ( @@ -123,9 +122,9 @@ func (tx *Tx) Rollback() error { var fn Rollbacker = RollbackFunc(func(context.Context, *Tx) error { return txDriver.tx.Rollback() }) - tx.mu.Lock() - hooks := append([]RollbackHook(nil), tx.onRollback...) - tx.mu.Unlock() + txDriver.mu.Lock() + hooks := append([]RollbackHook(nil), txDriver.onRollback...) + txDriver.mu.Unlock() for i := len(hooks) - 1; i >= 0; i-- { fn = hooks[i](fn) } @@ -134,9 +133,10 @@ func (tx *Tx) Rollback() error { // OnRollback adds a hook to call on rollback. func (tx *Tx) OnRollback(f RollbackHook) { - tx.mu.Lock() - defer tx.mu.Unlock() - tx.onRollback = append(tx.onRollback, f) + txDriver := tx.config.driver.(*txDriver) + txDriver.mu.Lock() + txDriver.onRollback = append(txDriver.onRollback, f) + txDriver.mu.Unlock() } // Client returns a Client that binds to current transaction. @@ -149,7 +149,9 @@ func (tx *Tx) Client() *Client { } func (tx *Tx) init() { - tx.Users = NewUsersClient(tx.config) + tx.Card = NewCardClient(tx.config) + tx.Group = NewGroupClient(tx.config) + tx.User = NewUserClient(tx.config) } // txDriver wraps the given dialect.Tx with a nop dialect.Driver implementation. @@ -159,7 +161,7 @@ func (tx *Tx) init() { // of them in order to commit or rollback the transaction. // // If a closed transaction is embedded in one of the generated entities, and the entity -// applies a query, for example: Users.QueryXXX(), the query will be executed +// applies a query, for example: Card.QueryXXX(), the query will be executed // through the driver which created this transaction. // // Note that txDriver is not goroutine safe. @@ -168,6 +170,10 @@ type txDriver struct { drv dialect.Driver // tx is the underlying transaction. tx dialect.Tx + // completion hooks. + mu sync.Mutex + onCommit []CommitHook + onRollback []RollbackHook } // newTx creates a new transactional driver. @@ -198,12 +204,12 @@ func (*txDriver) Commit() error { return nil } func (*txDriver) Rollback() error { return nil } // Exec calls tx.Exec. -func (tx *txDriver) Exec(ctx context.Context, query string, args, v interface{}) error { +func (tx *txDriver) Exec(ctx context.Context, query string, args, v any) error { return tx.tx.Exec(ctx, query, args, v) } // Query calls tx.Query. -func (tx *txDriver) Query(ctx context.Context, query string, args, v interface{}) error { +func (tx *txDriver) Query(ctx context.Context, query string, args, v any) error { return tx.tx.Query(ctx, query, args, v) } diff --git a/ent/user.go b/ent/user.go new file mode 100644 index 0000000..6577c5d --- /dev/null +++ b/ent/user.go @@ -0,0 +1,165 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "fmt" + "strings" + "t/ent/user" + "time" + + "entgo.io/ent/dialect/sql" +) + +// User is the model entity for the User schema. +type User struct { + config `json:"-"` + // ID of the ent. + ID int `json:"id,omitempty"` + // Username holds the value of the "username" field. + Username string `json:"username,omitempty"` + // CreatedAt holds the value of the "created_at" field. + CreatedAt time.Time `json:"created_at,omitempty"` + // UpdatedAt holds the value of the "updated_at" field. + UpdatedAt time.Time `json:"updated_at,omitempty"` + // Next holds the value of the "next" field. + Next string `json:"next,omitempty"` + // Edges holds the relations/edges for other nodes in the graph. + // The values are being populated by the UserQuery when eager-loading is set. + Edges UserEdges `json:"edges"` + group_users *int +} + +// UserEdges holds the relations/edges for other nodes in the graph. +type UserEdges struct { + // Card holds the value of the card edge. + Card []*Card `json:"card,omitempty"` + // loadedTypes holds the information for reporting if a + // type was loaded (or requested) in eager-loading or not. + loadedTypes [1]bool +} + +// CardOrErr returns the Card value or an error if the edge +// was not loaded in eager-loading. +func (e UserEdges) CardOrErr() ([]*Card, error) { + if e.loadedTypes[0] { + return e.Card, nil + } + return nil, &NotLoadedError{edge: "card"} +} + +// scanValues returns the types for scanning values from sql.Rows. +func (*User) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case user.FieldID: + values[i] = new(sql.NullInt64) + case user.FieldUsername, user.FieldNext: + values[i] = new(sql.NullString) + case user.FieldCreatedAt, user.FieldUpdatedAt: + values[i] = new(sql.NullTime) + case user.ForeignKeys[0]: // group_users + values[i] = new(sql.NullInt64) + default: + return nil, fmt.Errorf("unexpected column %q for type User", columns[i]) + } + } + return values, nil +} + +// assignValues assigns the values that were returned from sql.Rows (after scanning) +// to the User fields. +func (u *User) 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 user.FieldID: + value, ok := values[i].(*sql.NullInt64) + if !ok { + return fmt.Errorf("unexpected type %T for field id", value) + } + u.ID = int(value.Int64) + case user.FieldUsername: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field username", values[i]) + } else if value.Valid { + u.Username = value.String + } + case user.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 { + u.CreatedAt = value.Time + } + case user.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 { + u.UpdatedAt = value.Time + } + case user.FieldNext: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field next", values[i]) + } else if value.Valid { + u.Next = value.String + } + case user.ForeignKeys[0]: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for edge-field group_users", value) + } else if value.Valid { + u.group_users = new(int) + *u.group_users = int(value.Int64) + } + } + } + return nil +} + +// QueryCard queries the "card" edge of the User entity. +func (u *User) QueryCard() *CardQuery { + return NewUserClient(u.config).QueryCard(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. +func (u *User) Update() *UserUpdateOne { + return NewUserClient(u.config).UpdateOne(u) +} + +// Unwrap unwraps the User 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 (u *User) Unwrap() *User { + _tx, ok := u.config.driver.(*txDriver) + if !ok { + panic("ent: User is not a transactional entity") + } + u.config.driver = _tx.drv + return u +} + +// String implements the fmt.Stringer. +func (u *User) String() string { + var builder strings.Builder + builder.WriteString("User(") + builder.WriteString(fmt.Sprintf("id=%v, ", u.ID)) + builder.WriteString("username=") + builder.WriteString(u.Username) + builder.WriteString(", ") + builder.WriteString("created_at=") + builder.WriteString(u.CreatedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("updated_at=") + builder.WriteString(u.UpdatedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("next=") + builder.WriteString(u.Next) + builder.WriteByte(')') + return builder.String() +} + +// Users is a parsable slice of User. +type Users []*User diff --git a/ent/user/user.go b/ent/user/user.go new file mode 100644 index 0000000..394a63b --- /dev/null +++ b/ent/user/user.go @@ -0,0 +1,74 @@ +// Code generated by ent, DO NOT EDIT. + +package user + +import ( + "time" +) + +const ( + // Label holds the string label denoting the user type in the database. + Label = "user" + // FieldID holds the string denoting the id field in the database. + FieldID = "id" + // FieldUsername holds the string denoting the username field in the database. + FieldUsername = "username" + // FieldCreatedAt holds the string denoting the created_at field in the database. + FieldCreatedAt = "created_at" + // FieldUpdatedAt holds the string denoting the updated_at field in the database. + FieldUpdatedAt = "updated_at" + // FieldNext holds the string denoting the next field in the database. + FieldNext = "next" + // EdgeCard holds the string denoting the card edge name in mutations. + EdgeCard = "card" + // Table holds the table name of the user in the database. + Table = "users" + // CardTable is the table that holds the card relation/edge. + CardTable = "cards" + // CardInverseTable is the table name for the Card entity. + // It exists in this package in order to avoid circular dependency with the "card" package. + CardInverseTable = "cards" + // CardColumn is the table column denoting the card relation/edge. + CardColumn = "user_card" +) + +// Columns holds all SQL columns for user fields. +var Columns = []string{ + FieldID, + FieldUsername, + FieldCreatedAt, + FieldUpdatedAt, + FieldNext, +} + +// ForeignKeys holds the SQL foreign-keys that are owned by the "users" +// table and are not defined as standalone fields in the schema. +var ForeignKeys = []string{ + "group_users", +} + +// 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 ( + // UsernameValidator is a validator for the "username" field. It is called by the builders before save. + UsernameValidator func(string) error + // DefaultCreatedAt holds the default value on creation for the "created_at" field. + DefaultCreatedAt func() time.Time + // DefaultUpdatedAt holds the default value on creation for the "updated_at" field. + DefaultUpdatedAt func() time.Time + // DefaultNext holds the default value on creation for the "next" field. + DefaultNext string +) diff --git a/ent/user/where.go b/ent/user/where.go new file mode 100644 index 0000000..511b226 --- /dev/null +++ b/ent/user/where.go @@ -0,0 +1,375 @@ +// Code generated by ent, DO NOT EDIT. + +package user + +import ( + "t/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.User { + return predicate.User(sql.FieldEQ(FieldID, id)) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id int) predicate.User { + return predicate.User(sql.FieldEQ(FieldID, id)) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldID, id)) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldID, ids...)) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldID, ids...)) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id int) predicate.User { + return predicate.User(sql.FieldGT(FieldID, id)) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id int) predicate.User { + return predicate.User(sql.FieldGTE(FieldID, id)) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id int) predicate.User { + return predicate.User(sql.FieldLT(FieldID, id)) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id int) predicate.User { + return predicate.User(sql.FieldLTE(FieldID, id)) +} + +// Username applies equality check predicate on the "username" field. It's identical to UsernameEQ. +func Username(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldUsername, v)) +} + +// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ. +func CreatedAt(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldCreatedAt, v)) +} + +// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ. +func UpdatedAt(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// Next applies equality check predicate on the "next" field. It's identical to NextEQ. +func Next(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldNext, v)) +} + +// UsernameEQ applies the EQ predicate on the "username" field. +func UsernameEQ(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldUsername, v)) +} + +// UsernameNEQ applies the NEQ predicate on the "username" field. +func UsernameNEQ(v string) predicate.User { + return predicate.User(sql.FieldNEQ(FieldUsername, v)) +} + +// UsernameIn applies the In predicate on the "username" field. +func UsernameIn(vs ...string) predicate.User { + return predicate.User(sql.FieldIn(FieldUsername, vs...)) +} + +// UsernameNotIn applies the NotIn predicate on the "username" field. +func UsernameNotIn(vs ...string) predicate.User { + return predicate.User(sql.FieldNotIn(FieldUsername, vs...)) +} + +// UsernameGT applies the GT predicate on the "username" field. +func UsernameGT(v string) predicate.User { + return predicate.User(sql.FieldGT(FieldUsername, v)) +} + +// UsernameGTE applies the GTE predicate on the "username" field. +func UsernameGTE(v string) predicate.User { + return predicate.User(sql.FieldGTE(FieldUsername, v)) +} + +// UsernameLT applies the LT predicate on the "username" field. +func UsernameLT(v string) predicate.User { + return predicate.User(sql.FieldLT(FieldUsername, v)) +} + +// UsernameLTE applies the LTE predicate on the "username" field. +func UsernameLTE(v string) predicate.User { + return predicate.User(sql.FieldLTE(FieldUsername, v)) +} + +// UsernameContains applies the Contains predicate on the "username" field. +func UsernameContains(v string) predicate.User { + return predicate.User(sql.FieldContains(FieldUsername, v)) +} + +// UsernameHasPrefix applies the HasPrefix predicate on the "username" field. +func UsernameHasPrefix(v string) predicate.User { + return predicate.User(sql.FieldHasPrefix(FieldUsername, v)) +} + +// UsernameHasSuffix applies the HasSuffix predicate on the "username" field. +func UsernameHasSuffix(v string) predicate.User { + return predicate.User(sql.FieldHasSuffix(FieldUsername, v)) +} + +// UsernameEqualFold applies the EqualFold predicate on the "username" field. +func UsernameEqualFold(v string) predicate.User { + return predicate.User(sql.FieldEqualFold(FieldUsername, v)) +} + +// UsernameContainsFold applies the ContainsFold predicate on the "username" field. +func UsernameContainsFold(v string) predicate.User { + return predicate.User(sql.FieldContainsFold(FieldUsername, v)) +} + +// CreatedAtEQ applies the EQ predicate on the "created_at" field. +func CreatedAtEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldCreatedAt, v)) +} + +// CreatedAtNEQ applies the NEQ predicate on the "created_at" field. +func CreatedAtNEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldNEQ(FieldCreatedAt, v)) +} + +// CreatedAtIn applies the In predicate on the "created_at" field. +func CreatedAtIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldIn(FieldCreatedAt, vs...)) +} + +// CreatedAtNotIn applies the NotIn predicate on the "created_at" field. +func CreatedAtNotIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldNotIn(FieldCreatedAt, vs...)) +} + +// CreatedAtGT applies the GT predicate on the "created_at" field. +func CreatedAtGT(v time.Time) predicate.User { + return predicate.User(sql.FieldGT(FieldCreatedAt, v)) +} + +// CreatedAtGTE applies the GTE predicate on the "created_at" field. +func CreatedAtGTE(v time.Time) predicate.User { + return predicate.User(sql.FieldGTE(FieldCreatedAt, v)) +} + +// CreatedAtLT applies the LT predicate on the "created_at" field. +func CreatedAtLT(v time.Time) predicate.User { + return predicate.User(sql.FieldLT(FieldCreatedAt, v)) +} + +// CreatedAtLTE applies the LTE predicate on the "created_at" field. +func CreatedAtLTE(v time.Time) predicate.User { + return predicate.User(sql.FieldLTE(FieldCreatedAt, v)) +} + +// CreatedAtIsNil applies the IsNil predicate on the "created_at" field. +func CreatedAtIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldCreatedAt)) +} + +// CreatedAtNotNil applies the NotNil predicate on the "created_at" field. +func CreatedAtNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldCreatedAt)) +} + +// UpdatedAtEQ applies the EQ predicate on the "updated_at" field. +func UpdatedAtEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field. +func UpdatedAtNEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldNEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtIn applies the In predicate on the "updated_at" field. +func UpdatedAtIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field. +func UpdatedAtNotIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldNotIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtGT applies the GT predicate on the "updated_at" field. +func UpdatedAtGT(v time.Time) predicate.User { + return predicate.User(sql.FieldGT(FieldUpdatedAt, v)) +} + +// UpdatedAtGTE applies the GTE predicate on the "updated_at" field. +func UpdatedAtGTE(v time.Time) predicate.User { + return predicate.User(sql.FieldGTE(FieldUpdatedAt, v)) +} + +// UpdatedAtLT applies the LT predicate on the "updated_at" field. +func UpdatedAtLT(v time.Time) predicate.User { + return predicate.User(sql.FieldLT(FieldUpdatedAt, v)) +} + +// UpdatedAtLTE applies the LTE predicate on the "updated_at" field. +func UpdatedAtLTE(v time.Time) predicate.User { + return predicate.User(sql.FieldLTE(FieldUpdatedAt, v)) +} + +// UpdatedAtIsNil applies the IsNil predicate on the "updated_at" field. +func UpdatedAtIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldUpdatedAt)) +} + +// UpdatedAtNotNil applies the NotNil predicate on the "updated_at" field. +func UpdatedAtNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldUpdatedAt)) +} + +// NextEQ applies the EQ predicate on the "next" field. +func NextEQ(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldNext, v)) +} + +// NextNEQ applies the NEQ predicate on the "next" field. +func NextNEQ(v string) predicate.User { + return predicate.User(sql.FieldNEQ(FieldNext, v)) +} + +// NextIn applies the In predicate on the "next" field. +func NextIn(vs ...string) predicate.User { + return predicate.User(sql.FieldIn(FieldNext, vs...)) +} + +// NextNotIn applies the NotIn predicate on the "next" field. +func NextNotIn(vs ...string) predicate.User { + return predicate.User(sql.FieldNotIn(FieldNext, vs...)) +} + +// NextGT applies the GT predicate on the "next" field. +func NextGT(v string) predicate.User { + return predicate.User(sql.FieldGT(FieldNext, v)) +} + +// NextGTE applies the GTE predicate on the "next" field. +func NextGTE(v string) predicate.User { + return predicate.User(sql.FieldGTE(FieldNext, v)) +} + +// NextLT applies the LT predicate on the "next" field. +func NextLT(v string) predicate.User { + return predicate.User(sql.FieldLT(FieldNext, v)) +} + +// NextLTE applies the LTE predicate on the "next" field. +func NextLTE(v string) predicate.User { + return predicate.User(sql.FieldLTE(FieldNext, v)) +} + +// NextContains applies the Contains predicate on the "next" field. +func NextContains(v string) predicate.User { + return predicate.User(sql.FieldContains(FieldNext, v)) +} + +// NextHasPrefix applies the HasPrefix predicate on the "next" field. +func NextHasPrefix(v string) predicate.User { + return predicate.User(sql.FieldHasPrefix(FieldNext, v)) +} + +// NextHasSuffix applies the HasSuffix predicate on the "next" field. +func NextHasSuffix(v string) predicate.User { + return predicate.User(sql.FieldHasSuffix(FieldNext, v)) +} + +// NextIsNil applies the IsNil predicate on the "next" field. +func NextIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldNext)) +} + +// NextNotNil applies the NotNil predicate on the "next" field. +func NextNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldNext)) +} + +// NextEqualFold applies the EqualFold predicate on the "next" field. +func NextEqualFold(v string) predicate.User { + return predicate.User(sql.FieldEqualFold(FieldNext, v)) +} + +// NextContainsFold applies the ContainsFold predicate on the "next" field. +func NextContainsFold(v string) predicate.User { + return predicate.User(sql.FieldContainsFold(FieldNext, v)) +} + +// HasCard applies the HasEdge predicate on the "card" edge. +func HasCard() predicate.User { + return predicate.User(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, CardTable, CardColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasCardWith applies the HasEdge predicate on the "card" edge with a given conditions (other predicates). +func HasCardWith(preds ...predicate.Card) predicate.User { + return predicate.User(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(CardInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, CardTable, CardColumn), + ) + 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) { + 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.User) predicate.User { + return predicate.User(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.User) predicate.User { + return predicate.User(func(s *sql.Selector) { + p(s.Not()) + }) +} diff --git a/ent/user_create.go b/ent/user_create.go new file mode 100644 index 0000000..71163b6 --- /dev/null +++ b/ent/user_create.go @@ -0,0 +1,292 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "t/ent/card" + "t/ent/user" + "time" + + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// UserCreate is the builder for creating a User entity. +type UserCreate struct { + config + mutation *UserMutation + hooks []Hook +} + +// SetUsername sets the "username" field. +func (uc *UserCreate) SetUsername(s string) *UserCreate { + uc.mutation.SetUsername(s) + return uc +} + +// SetCreatedAt sets the "created_at" field. +func (uc *UserCreate) SetCreatedAt(t time.Time) *UserCreate { + uc.mutation.SetCreatedAt(t) + return uc +} + +// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. +func (uc *UserCreate) SetNillableCreatedAt(t *time.Time) *UserCreate { + if t != nil { + uc.SetCreatedAt(*t) + } + return uc +} + +// SetUpdatedAt sets the "updated_at" field. +func (uc *UserCreate) SetUpdatedAt(t time.Time) *UserCreate { + uc.mutation.SetUpdatedAt(t) + return uc +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (uc *UserCreate) SetNillableUpdatedAt(t *time.Time) *UserCreate { + if t != nil { + uc.SetUpdatedAt(*t) + } + return uc +} + +// SetNext sets the "next" field. +func (uc *UserCreate) SetNext(s string) *UserCreate { + uc.mutation.SetNext(s) + return uc +} + +// SetNillableNext sets the "next" field if the given value is not nil. +func (uc *UserCreate) SetNillableNext(s *string) *UserCreate { + if s != nil { + uc.SetNext(*s) + } + return uc +} + +// AddCardIDs adds the "card" edge to the Card entity by IDs. +func (uc *UserCreate) AddCardIDs(ids ...int) *UserCreate { + uc.mutation.AddCardIDs(ids...) + return uc +} + +// AddCard adds the "card" edges to the Card entity. +func (uc *UserCreate) AddCard(c ...*Card) *UserCreate { + ids := make([]int, len(c)) + for i := range c { + ids[i] = c[i].ID + } + return uc.AddCardIDs(ids...) +} + +// Mutation returns the UserMutation object of the builder. +func (uc *UserCreate) Mutation() *UserMutation { + return uc.mutation +} + +// Save creates the User in the database. +func (uc *UserCreate) Save(ctx context.Context) (*User, error) { + uc.defaults() + return withHooks[*User, UserMutation](ctx, uc.sqlSave, uc.mutation, uc.hooks) +} + +// SaveX calls Save and panics if Save returns an error. +func (uc *UserCreate) SaveX(ctx context.Context) *User { + v, err := uc.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (uc *UserCreate) Exec(ctx context.Context) error { + _, err := uc.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (uc *UserCreate) ExecX(ctx context.Context) { + if err := uc.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (uc *UserCreate) defaults() { + if _, ok := uc.mutation.CreatedAt(); !ok { + v := user.DefaultCreatedAt() + uc.mutation.SetCreatedAt(v) + } + if _, ok := uc.mutation.UpdatedAt(); !ok { + v := user.DefaultUpdatedAt() + uc.mutation.SetUpdatedAt(v) + } + if _, ok := uc.mutation.Next(); !ok { + v := user.DefaultNext + uc.mutation.SetNext(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (uc *UserCreate) check() error { + if _, ok := uc.mutation.Username(); !ok { + return &ValidationError{Name: "username", err: errors.New(`ent: missing required field "User.username"`)} + } + if v, ok := uc.mutation.Username(); ok { + if err := user.UsernameValidator(v); err != nil { + return &ValidationError{Name: "username", err: fmt.Errorf(`ent: validator failed for field "User.username": %w`, err)} + } + } + return nil +} + +func (uc *UserCreate) sqlSave(ctx context.Context) (*User, error) { + if err := uc.check(); err != nil { + return nil, err + } + _node, _spec := uc.createSpec() + if err := sqlgraph.CreateNode(ctx, uc.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) + uc.mutation.id = &_node.ID + uc.mutation.done = true + return _node, nil +} + +func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { + var ( + _node = &User{config: uc.config} + _spec = sqlgraph.NewCreateSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) + ) + if value, ok := uc.mutation.Username(); ok { + _spec.SetField(user.FieldUsername, field.TypeString, value) + _node.Username = value + } + if value, ok := uc.mutation.CreatedAt(); ok { + _spec.SetField(user.FieldCreatedAt, field.TypeTime, value) + _node.CreatedAt = value + } + if value, ok := uc.mutation.UpdatedAt(); ok { + _spec.SetField(user.FieldUpdatedAt, field.TypeTime, value) + _node.UpdatedAt = value + } + if value, ok := uc.mutation.Next(); ok { + _spec.SetField(user.FieldNext, field.TypeString, value) + _node.Next = value + } + if nodes := uc.mutation.CardIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.CardTable, + Columns: []string{user.CardColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: card.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } + return _node, _spec +} + +// UserCreateBulk is the builder for creating many User entities in bulk. +type UserCreateBulk struct { + config + builders []*UserCreate +} + +// Save creates the User entities in the database. +func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) + nodes := make([]*User, len(ucb.builders)) + mutators := make([]Mutator, len(ucb.builders)) + for i := range ucb.builders { + func(i int, root context.Context) { + builder := ucb.builders[i] + builder.defaults() + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*UserMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + nodes[i], specs[i] = builder.createSpec() + var err error + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, ucb.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, ucb.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, ucb.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (ucb *UserCreateBulk) SaveX(ctx context.Context) []*User { + v, err := ucb.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (ucb *UserCreateBulk) Exec(ctx context.Context) error { + _, err := ucb.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (ucb *UserCreateBulk) ExecX(ctx context.Context) { + if err := ucb.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/ent/user_delete.go b/ent/user_delete.go new file mode 100644 index 0000000..3ae1ce7 --- /dev/null +++ b/ent/user_delete.go @@ -0,0 +1,88 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "t/ent/predicate" + "t/ent/user" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// UserDelete is the builder for deleting a User entity. +type UserDelete struct { + config + hooks []Hook + mutation *UserMutation +} + +// Where appends a list predicates to the UserDelete builder. +func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete { + ud.mutation.Where(ps...) + return ud +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (ud *UserDelete) Exec(ctx context.Context) (int, error) { + return withHooks[int, UserMutation](ctx, ud.sqlExec, ud.mutation, ud.hooks) +} + +// ExecX is like Exec, but panics if an error occurs. +func (ud *UserDelete) ExecX(ctx context.Context) int { + n, err := ud.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +func (ud *UserDelete) sqlExec(ctx context.Context) (int, error) { + _spec := sqlgraph.NewDeleteSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) + if ps := ud.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, ud.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + ud.mutation.done = true + return affected, err +} + +// UserDeleteOne is the builder for deleting a single User entity. +type UserDeleteOne struct { + ud *UserDelete +} + +// Where appends a list predicates to the UserDelete builder. +func (udo *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne { + udo.ud.mutation.Where(ps...) + return udo +} + +// Exec executes the deletion query. +func (udo *UserDeleteOne) Exec(ctx context.Context) error { + n, err := udo.ud.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{user.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (udo *UserDeleteOne) ExecX(ctx context.Context) { + if err := udo.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/ent/user_query.go b/ent/user_query.go new file mode 100644 index 0000000..ac8123f --- /dev/null +++ b/ent/user_query.go @@ -0,0 +1,611 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "database/sql/driver" + "fmt" + "math" + "t/ent/card" + "t/ent/predicate" + "t/ent/user" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// UserQuery is the builder for querying User entities. +type UserQuery struct { + config + ctx *QueryContext + order []OrderFunc + inters []Interceptor + predicates []predicate.User + withCard *CardQuery + 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 UserQuery builder. +func (uq *UserQuery) Where(ps ...predicate.User) *UserQuery { + uq.predicates = append(uq.predicates, ps...) + return uq +} + +// Limit the number of records to be returned by this query. +func (uq *UserQuery) Limit(limit int) *UserQuery { + uq.ctx.Limit = &limit + return uq +} + +// Offset to start from. +func (uq *UserQuery) Offset(offset int) *UserQuery { + uq.ctx.Offset = &offset + return uq +} + +// 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 (uq *UserQuery) Unique(unique bool) *UserQuery { + uq.ctx.Unique = &unique + return uq +} + +// Order specifies how the records should be ordered. +func (uq *UserQuery) Order(o ...OrderFunc) *UserQuery { + uq.order = append(uq.order, o...) + return uq +} + +// QueryCard chains the current query on the "card" edge. +func (uq *UserQuery) QueryCard() *CardQuery { + query := (&CardClient{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(card.Table, card.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, user.CardTable, user.CardColumn), + ) + 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) { + nodes, err := uq.Limit(1).All(setContextOp(ctx, uq.ctx, "First")) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{user.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (uq *UserQuery) FirstX(ctx context.Context) *User { + node, err := uq.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first User ID from the query. +// Returns a *NotFoundError when no User ID was found. +func (uq *UserQuery) FirstID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = uq.Limit(1).IDs(setContextOp(ctx, uq.ctx, "FirstID")); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{user.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (uq *UserQuery) FirstIDX(ctx context.Context) int { + id, err := uq.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single User entity found by the query, ensuring it only returns one. +// Returns a *NotSingularError when more than one User entity is found. +// Returns a *NotFoundError when no User entities are found. +func (uq *UserQuery) Only(ctx context.Context) (*User, error) { + nodes, err := uq.Limit(2).All(setContextOp(ctx, uq.ctx, "Only")) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{user.Label} + default: + return nil, &NotSingularError{user.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (uq *UserQuery) OnlyX(ctx context.Context) *User { + node, err := uq.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only User ID in the query. +// Returns a *NotSingularError when more than one User ID is found. +// Returns a *NotFoundError when no entities are found. +func (uq *UserQuery) OnlyID(ctx context.Context) (id int, err error) { + var ids []int + if ids, err = uq.Limit(2).IDs(setContextOp(ctx, uq.ctx, "OnlyID")); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{user.Label} + default: + err = &NotSingularError{user.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (uq *UserQuery) OnlyIDX(ctx context.Context) int { + id, err := uq.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of Users. +func (uq *UserQuery) All(ctx context.Context) ([]*User, error) { + ctx = setContextOp(ctx, uq.ctx, "All") + if err := uq.prepareQuery(ctx); err != nil { + return nil, err + } + qr := querierAll[[]*User, *UserQuery]() + return withInterceptors[[]*User](ctx, uq, qr, uq.inters) +} + +// AllX is like All, but panics if an error occurs. +func (uq *UserQuery) AllX(ctx context.Context) []*User { + nodes, err := uq.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// IDs executes the query and returns a list of User IDs. +func (uq *UserQuery) IDs(ctx context.Context) (ids []int, err error) { + if uq.ctx.Unique == nil && uq.path != nil { + uq.Unique(true) + } + ctx = setContextOp(ctx, uq.ctx, "IDs") + if err = uq.Select(user.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (uq *UserQuery) IDsX(ctx context.Context) []int { + ids, err := uq.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (uq *UserQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, uq.ctx, "Count") + if err := uq.prepareQuery(ctx); err != nil { + return 0, err + } + return withInterceptors[int](ctx, uq, querierCount[*UserQuery](), uq.inters) +} + +// CountX is like Count, but panics if an error occurs. +func (uq *UserQuery) CountX(ctx context.Context) int { + count, err := uq.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (uq *UserQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, uq.ctx, "Exist") + switch _, err := uq.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 (uq *UserQuery) ExistX(ctx context.Context) bool { + exist, err := uq.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the UserQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (uq *UserQuery) Clone() *UserQuery { + if uq == nil { + return nil + } + return &UserQuery{ + config: uq.config, + ctx: uq.ctx.Clone(), + order: append([]OrderFunc{}, uq.order...), + inters: append([]Interceptor{}, uq.inters...), + predicates: append([]predicate.User{}, uq.predicates...), + withCard: uq.withCard.Clone(), + // clone intermediate query. + sql: uq.sql.Clone(), + path: uq.path, + } +} + +// WithCard tells the query-builder to eager-load the nodes that are connected to +// the "card" edge. The optional arguments are used to configure the query builder of the edge. +func (uq *UserQuery) WithCard(opts ...func(*CardQuery)) *UserQuery { + query := (&CardClient{config: uq.config}).Query() + for _, opt := range opts { + opt(query) + } + uq.withCard = 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. +// +// Example: +// +// var v []struct { +// Username string `json:"username,omitempty"` +// Count int `json:"count,omitempty"` +// } +// +// client.User.Query(). +// GroupBy(user.FieldUsername). +// Aggregate(ent.Count()). +// Scan(ctx, &v) +func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy { + uq.ctx.Fields = append([]string{field}, fields...) + grbuild := &UserGroupBy{build: uq} + grbuild.flds = &uq.ctx.Fields + grbuild.label = user.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 { +// Username string `json:"username,omitempty"` +// } +// +// client.User.Query(). +// Select(user.FieldUsername). +// Scan(ctx, &v) +func (uq *UserQuery) Select(fields ...string) *UserSelect { + uq.ctx.Fields = append(uq.ctx.Fields, fields...) + sbuild := &UserSelect{UserQuery: uq} + sbuild.label = user.Label + sbuild.flds, sbuild.scan = &uq.ctx.Fields, sbuild.Scan + return sbuild +} + +// Aggregate returns a UserSelect configured with the given aggregations. +func (uq *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect { + return uq.Select().Aggregate(fns...) +} + +func (uq *UserQuery) prepareQuery(ctx context.Context) error { + for _, inter := range uq.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, uq); err != nil { + return err + } + } + } + for _, f := range uq.ctx.Fields { + if !user.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + } + if uq.path != nil { + prev, err := uq.path(ctx) + if err != nil { + return err + } + uq.sql = prev + } + return nil +} + +func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, error) { + var ( + nodes = []*User{} + withFKs = uq.withFKs + _spec = uq.querySpec() + loadedTypes = [1]bool{ + uq.withCard != nil, + } + ) + if withFKs { + _spec.Node.Columns = append(_spec.Node.Columns, user.ForeignKeys...) + } + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*User).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &User{config: uq.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, uq.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + if query := uq.withCard; query != nil { + if err := uq.loadCard(ctx, query, nodes, + func(n *User) { n.Edges.Card = []*Card{} }, + func(n *User, e *Card) { n.Edges.Card = append(n.Edges.Card, e) }); err != nil { + return nil, err + } + } + return nodes, nil +} + +func (uq *UserQuery) loadCard(ctx context.Context, query *CardQuery, nodes []*User, init func(*User), assign func(*User, *Card)) 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.Card(func(s *sql.Selector) { + s.Where(sql.InValues(user.CardColumn, fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.user_card + if fk == nil { + return fmt.Errorf(`foreign-key "user_card" is nil for node %v`, n.ID) + } + node, ok := nodeids[*fk] + if !ok { + return fmt.Errorf(`unexpected foreign-key "user_card" 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() + _spec.Node.Columns = uq.ctx.Fields + if len(uq.ctx.Fields) > 0 { + _spec.Unique = uq.ctx.Unique != nil && *uq.ctx.Unique + } + return sqlgraph.CountNodes(ctx, uq.driver, _spec) +} + +func (uq *UserQuery) querySpec() *sqlgraph.QuerySpec { + _spec := sqlgraph.NewQuerySpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) + _spec.From = uq.sql + if unique := uq.ctx.Unique; unique != nil { + _spec.Unique = *unique + } else if uq.path != nil { + _spec.Unique = true + } + if fields := uq.ctx.Fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, user.FieldID) + for i := range fields { + if fields[i] != user.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + } + if ps := uq.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := uq.ctx.Limit; limit != nil { + _spec.Limit = *limit + } + if offset := uq.ctx.Offset; offset != nil { + _spec.Offset = *offset + } + if ps := uq.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (uq *UserQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(uq.driver.Dialect()) + t1 := builder.Table(user.Table) + columns := uq.ctx.Fields + if len(columns) == 0 { + columns = user.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if uq.sql != nil { + selector = uq.sql + selector.Select(selector.Columns(columns...)...) + } + if uq.ctx.Unique != nil && *uq.ctx.Unique { + selector.Distinct() + } + for _, p := range uq.predicates { + p(selector) + } + for _, p := range uq.order { + p(selector) + } + if offset := uq.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 := uq.ctx.Limit; limit != nil { + selector.Limit(*limit) + } + return selector +} + +// UserGroupBy is the group-by builder for User entities. +type UserGroupBy struct { + selector + build *UserQuery +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (ugb *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy { + ugb.fns = append(ugb.fns, fns...) + return ugb +} + +// Scan applies the selector query and scans the result into the given value. +func (ugb *UserGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, ugb.build.ctx, "GroupBy") + if err := ugb.build.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*UserQuery, *UserGroupBy](ctx, ugb.build, ugb, ugb.build.inters, v) +} + +func (ugb *UserGroupBy) sqlScan(ctx context.Context, root *UserQuery, v any) error { + selector := root.sqlQuery(ctx).Select() + aggregation := make([]string, 0, len(ugb.fns)) + for _, fn := range ugb.fns { + aggregation = append(aggregation, fn(selector)) + } + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(*ugb.flds)+len(ugb.fns)) + for _, f := range *ugb.flds { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + selector.GroupBy(selector.Columns(*ugb.flds...)...) + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := ugb.build.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// UserSelect is the builder for selecting fields of User entities. +type UserSelect struct { + *UserQuery + selector +} + +// Aggregate adds the given aggregation functions to the selector query. +func (us *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect { + us.fns = append(us.fns, fns...) + return us +} + +// Scan applies the selector query and scans the result into the given value. +func (us *UserSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, us.ctx, "Select") + if err := us.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*UserQuery, *UserSelect](ctx, us.UserQuery, us, us.inters, v) +} + +func (us *UserSelect) sqlScan(ctx context.Context, root *UserQuery, v any) error { + selector := root.sqlQuery(ctx) + aggregation := make([]string, 0, len(us.fns)) + for _, fn := range us.fns { + aggregation = append(aggregation, fn(selector)) + } + switch n := len(*us.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 := us.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} diff --git a/ent/user_update.go b/ent/user_update.go new file mode 100644 index 0000000..c43b793 --- /dev/null +++ b/ent/user_update.go @@ -0,0 +1,467 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "t/ent/card" + "t/ent/predicate" + "t/ent/user" + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" +) + +// UserUpdate is the builder for updating User entities. +type UserUpdate struct { + config + hooks []Hook + mutation *UserMutation +} + +// Where appends a list predicates to the UserUpdate builder. +func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate { + uu.mutation.Where(ps...) + return uu +} + +// SetUpdatedAt sets the "updated_at" field. +func (uu *UserUpdate) SetUpdatedAt(t time.Time) *UserUpdate { + uu.mutation.SetUpdatedAt(t) + return uu +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (uu *UserUpdate) SetNillableUpdatedAt(t *time.Time) *UserUpdate { + if t != nil { + uu.SetUpdatedAt(*t) + } + return uu +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (uu *UserUpdate) ClearUpdatedAt() *UserUpdate { + uu.mutation.ClearUpdatedAt() + return uu +} + +// SetNext sets the "next" field. +func (uu *UserUpdate) SetNext(s string) *UserUpdate { + uu.mutation.SetNext(s) + return uu +} + +// SetNillableNext sets the "next" field if the given value is not nil. +func (uu *UserUpdate) SetNillableNext(s *string) *UserUpdate { + if s != nil { + uu.SetNext(*s) + } + return uu +} + +// ClearNext clears the value of the "next" field. +func (uu *UserUpdate) ClearNext() *UserUpdate { + uu.mutation.ClearNext() + return uu +} + +// AddCardIDs adds the "card" edge to the Card entity by IDs. +func (uu *UserUpdate) AddCardIDs(ids ...int) *UserUpdate { + uu.mutation.AddCardIDs(ids...) + return uu +} + +// AddCard adds the "card" edges to the Card entity. +func (uu *UserUpdate) AddCard(c ...*Card) *UserUpdate { + ids := make([]int, len(c)) + for i := range c { + ids[i] = c[i].ID + } + return uu.AddCardIDs(ids...) +} + +// Mutation returns the UserMutation object of the builder. +func (uu *UserUpdate) Mutation() *UserMutation { + return uu.mutation +} + +// ClearCard clears all "card" edges to the Card entity. +func (uu *UserUpdate) ClearCard() *UserUpdate { + uu.mutation.ClearCard() + return uu +} + +// RemoveCardIDs removes the "card" edge to Card entities by IDs. +func (uu *UserUpdate) RemoveCardIDs(ids ...int) *UserUpdate { + uu.mutation.RemoveCardIDs(ids...) + return uu +} + +// RemoveCard removes "card" edges to Card entities. +func (uu *UserUpdate) RemoveCard(c ...*Card) *UserUpdate { + ids := make([]int, len(c)) + for i := range c { + ids[i] = c[i].ID + } + return uu.RemoveCardIDs(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) +} + +// SaveX is like Save, but panics if an error occurs. +func (uu *UserUpdate) SaveX(ctx context.Context) int { + affected, err := uu.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (uu *UserUpdate) Exec(ctx context.Context) error { + _, err := uu.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (uu *UserUpdate) ExecX(ctx context.Context) { + if err := uu.Exec(ctx); err != nil { + panic(err) + } +} + +func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { + _spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) + if ps := uu.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if uu.mutation.CreatedAtCleared() { + _spec.ClearField(user.FieldCreatedAt, field.TypeTime) + } + if value, ok := uu.mutation.UpdatedAt(); ok { + _spec.SetField(user.FieldUpdatedAt, field.TypeTime, value) + } + if uu.mutation.UpdatedAtCleared() { + _spec.ClearField(user.FieldUpdatedAt, field.TypeTime) + } + if value, ok := uu.mutation.Next(); ok { + _spec.SetField(user.FieldNext, field.TypeString, value) + } + if uu.mutation.NextCleared() { + _spec.ClearField(user.FieldNext, field.TypeString) + } + if uu.mutation.CardCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.CardTable, + Columns: []string{user.CardColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: card.FieldID, + }, + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := uu.mutation.RemovedCardIDs(); len(nodes) > 0 && !uu.mutation.CardCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.CardTable, + Columns: []string{user.CardColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: card.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := uu.mutation.CardIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.CardTable, + Columns: []string{user.CardColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: card.FieldID, + }, + }, + } + 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} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + uu.mutation.done = true + return n, nil +} + +// UserUpdateOne is the builder for updating a single User entity. +type UserUpdateOne struct { + config + fields []string + hooks []Hook + mutation *UserMutation +} + +// SetUpdatedAt sets the "updated_at" field. +func (uuo *UserUpdateOne) SetUpdatedAt(t time.Time) *UserUpdateOne { + uuo.mutation.SetUpdatedAt(t) + return uuo +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableUpdatedAt(t *time.Time) *UserUpdateOne { + if t != nil { + uuo.SetUpdatedAt(*t) + } + return uuo +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (uuo *UserUpdateOne) ClearUpdatedAt() *UserUpdateOne { + uuo.mutation.ClearUpdatedAt() + return uuo +} + +// SetNext sets the "next" field. +func (uuo *UserUpdateOne) SetNext(s string) *UserUpdateOne { + uuo.mutation.SetNext(s) + return uuo +} + +// SetNillableNext sets the "next" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableNext(s *string) *UserUpdateOne { + if s != nil { + uuo.SetNext(*s) + } + return uuo +} + +// ClearNext clears the value of the "next" field. +func (uuo *UserUpdateOne) ClearNext() *UserUpdateOne { + uuo.mutation.ClearNext() + return uuo +} + +// AddCardIDs adds the "card" edge to the Card entity by IDs. +func (uuo *UserUpdateOne) AddCardIDs(ids ...int) *UserUpdateOne { + uuo.mutation.AddCardIDs(ids...) + return uuo +} + +// AddCard adds the "card" edges to the Card entity. +func (uuo *UserUpdateOne) AddCard(c ...*Card) *UserUpdateOne { + ids := make([]int, len(c)) + for i := range c { + ids[i] = c[i].ID + } + return uuo.AddCardIDs(ids...) +} + +// Mutation returns the UserMutation object of the builder. +func (uuo *UserUpdateOne) Mutation() *UserMutation { + return uuo.mutation +} + +// ClearCard clears all "card" edges to the Card entity. +func (uuo *UserUpdateOne) ClearCard() *UserUpdateOne { + uuo.mutation.ClearCard() + return uuo +} + +// RemoveCardIDs removes the "card" edge to Card entities by IDs. +func (uuo *UserUpdateOne) RemoveCardIDs(ids ...int) *UserUpdateOne { + uuo.mutation.RemoveCardIDs(ids...) + return uuo +} + +// RemoveCard removes "card" edges to Card entities. +func (uuo *UserUpdateOne) RemoveCard(c ...*Card) *UserUpdateOne { + ids := make([]int, len(c)) + for i := range c { + ids[i] = c[i].ID + } + return uuo.RemoveCardIDs(ids...) +} + +// Where appends a list predicates to the UserUpdate builder. +func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne { + uuo.mutation.Where(ps...) + return uuo +} + +// Select allows selecting one or more fields (columns) of the returned entity. +// The default is selecting all fields defined in the entity schema. +func (uuo *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne { + uuo.fields = append([]string{field}, fields...) + return uuo +} + +// Save executes the query and returns the updated User entity. +func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error) { + return withHooks[*User, UserMutation](ctx, uuo.sqlSave, uuo.mutation, uuo.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (uuo *UserUpdateOne) SaveX(ctx context.Context) *User { + node, err := uuo.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (uuo *UserUpdateOne) Exec(ctx context.Context) error { + _, err := uuo.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (uuo *UserUpdateOne) ExecX(ctx context.Context) { + if err := uuo.Exec(ctx); err != nil { + panic(err) + } +} + +func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) { + _spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt)) + id, ok := uuo.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "User.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := uuo.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, user.FieldID) + for _, f := range fields { + if !user.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + if f != user.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := uuo.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if uuo.mutation.CreatedAtCleared() { + _spec.ClearField(user.FieldCreatedAt, field.TypeTime) + } + if value, ok := uuo.mutation.UpdatedAt(); ok { + _spec.SetField(user.FieldUpdatedAt, field.TypeTime, value) + } + if uuo.mutation.UpdatedAtCleared() { + _spec.ClearField(user.FieldUpdatedAt, field.TypeTime) + } + if value, ok := uuo.mutation.Next(); ok { + _spec.SetField(user.FieldNext, field.TypeString, value) + } + if uuo.mutation.NextCleared() { + _spec.ClearField(user.FieldNext, field.TypeString) + } + if uuo.mutation.CardCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.CardTable, + Columns: []string{user.CardColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: card.FieldID, + }, + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := uuo.mutation.RemovedCardIDs(); len(nodes) > 0 && !uuo.mutation.CardCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.CardTable, + Columns: []string{user.CardColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: card.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := uuo.mutation.CardIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: user.CardTable, + Columns: []string{user.CardColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Column: card.FieldID, + }, + }, + } + 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 + if err = sqlgraph.UpdateNode(ctx, uuo.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{user.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + uuo.mutation.done = true + return _node, nil +} diff --git a/ent/users.go b/ent/users.go deleted file mode 100644 index 621fdea..0000000 --- a/ent/users.go +++ /dev/null @@ -1,276 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package ent - -import ( - "fmt" - "strings" - "t/ent/users" - "time" - - "entgo.io/ent/dialect/sql" -) - -// Users is the model entity for the Users schema. -type Users struct { - config `json:"-"` - // ID of the ent. - ID int `json:"id,omitempty"` - // User holds the value of the "user" field. - User string `json:"user,omitempty"` - // Chara holds the value of the "chara" field. - Chara string `json:"chara,omitempty"` - // Skill holds the value of the "skill" field. - Skill int `json:"skill,omitempty"` - // Hp holds the value of the "hp" field. - Hp int `json:"hp,omitempty"` - // Attack holds the value of the "attack" field. - Attack int `json:"attack,omitempty"` - // Defense holds the value of the "defense" field. - Defense int `json:"defense,omitempty"` - // Critical holds the value of the "critical" field. - Critical int `json:"critical,omitempty"` - // Battle holds the value of the "battle" field. - Battle int `json:"battle,omitempty"` - // Win holds the value of the "win" field. - Win int `json:"win,omitempty"` - // Day holds the value of the "day" field. - Day int `json:"day,omitempty"` - // Percentage holds the value of the "percentage" field. - Percentage float64 `json:"percentage,omitempty"` - // Limit holds the value of the "limit" field. - Limit bool `json:"limit,omitempty"` - // Status holds the value of the "status" field. - Status string `json:"status,omitempty"` - // Comment holds the value of the "comment" field. - Comment string `json:"comment,omitempty"` - // CreatedAt holds the value of the "created_at" field. - CreatedAt time.Time `json:"created_at,omitempty"` - // Next holds the value of the "next" field. - Next string `json:"next,omitempty"` - // UpdatedAt holds the value of the "updated_at" field. - UpdatedAt time.Time `json:"updated_at,omitempty"` - // URL holds the value of the "url" field. - URL string `json:"url,omitempty"` -} - -// scanValues returns the types for scanning values from sql.Rows. -func (*Users) scanValues(columns []string) ([]interface{}, error) { - values := make([]interface{}, len(columns)) - for i := range columns { - switch columns[i] { - case users.FieldLimit: - values[i] = new(sql.NullBool) - case users.FieldPercentage: - values[i] = new(sql.NullFloat64) - case users.FieldID, users.FieldSkill, users.FieldHp, users.FieldAttack, users.FieldDefense, users.FieldCritical, users.FieldBattle, users.FieldWin, users.FieldDay: - values[i] = new(sql.NullInt64) - case users.FieldUser, users.FieldChara, users.FieldStatus, users.FieldComment, users.FieldNext, users.FieldURL: - values[i] = new(sql.NullString) - case users.FieldCreatedAt, users.FieldUpdatedAt: - values[i] = new(sql.NullTime) - default: - return nil, fmt.Errorf("unexpected column %q for type Users", columns[i]) - } - } - return values, nil -} - -// assignValues assigns the values that were returned from sql.Rows (after scanning) -// to the Users fields. -func (u *Users) assignValues(columns []string, values []interface{}) 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 users.FieldID: - value, ok := values[i].(*sql.NullInt64) - if !ok { - return fmt.Errorf("unexpected type %T for field id", value) - } - u.ID = int(value.Int64) - case users.FieldUser: - if value, ok := values[i].(*sql.NullString); !ok { - return fmt.Errorf("unexpected type %T for field user", values[i]) - } else if value.Valid { - u.User = value.String - } - case users.FieldChara: - if value, ok := values[i].(*sql.NullString); !ok { - return fmt.Errorf("unexpected type %T for field chara", values[i]) - } else if value.Valid { - u.Chara = value.String - } - case users.FieldSkill: - if value, ok := values[i].(*sql.NullInt64); !ok { - return fmt.Errorf("unexpected type %T for field skill", values[i]) - } else if value.Valid { - u.Skill = int(value.Int64) - } - case users.FieldHp: - if value, ok := values[i].(*sql.NullInt64); !ok { - return fmt.Errorf("unexpected type %T for field hp", values[i]) - } else if value.Valid { - u.Hp = int(value.Int64) - } - case users.FieldAttack: - if value, ok := values[i].(*sql.NullInt64); !ok { - return fmt.Errorf("unexpected type %T for field attack", values[i]) - } else if value.Valid { - u.Attack = int(value.Int64) - } - case users.FieldDefense: - if value, ok := values[i].(*sql.NullInt64); !ok { - return fmt.Errorf("unexpected type %T for field defense", values[i]) - } else if value.Valid { - u.Defense = int(value.Int64) - } - case users.FieldCritical: - if value, ok := values[i].(*sql.NullInt64); !ok { - return fmt.Errorf("unexpected type %T for field critical", values[i]) - } else if value.Valid { - u.Critical = int(value.Int64) - } - case users.FieldBattle: - if value, ok := values[i].(*sql.NullInt64); !ok { - return fmt.Errorf("unexpected type %T for field battle", values[i]) - } else if value.Valid { - u.Battle = int(value.Int64) - } - case users.FieldWin: - if value, ok := values[i].(*sql.NullInt64); !ok { - return fmt.Errorf("unexpected type %T for field win", values[i]) - } else if value.Valid { - u.Win = int(value.Int64) - } - case users.FieldDay: - if value, ok := values[i].(*sql.NullInt64); !ok { - return fmt.Errorf("unexpected type %T for field day", values[i]) - } else if value.Valid { - u.Day = int(value.Int64) - } - case users.FieldPercentage: - if value, ok := values[i].(*sql.NullFloat64); !ok { - return fmt.Errorf("unexpected type %T for field percentage", values[i]) - } else if value.Valid { - u.Percentage = value.Float64 - } - case users.FieldLimit: - if value, ok := values[i].(*sql.NullBool); !ok { - return fmt.Errorf("unexpected type %T for field limit", values[i]) - } else if value.Valid { - u.Limit = value.Bool - } - case users.FieldStatus: - if value, ok := values[i].(*sql.NullString); !ok { - return fmt.Errorf("unexpected type %T for field status", values[i]) - } else if value.Valid { - u.Status = value.String - } - case users.FieldComment: - if value, ok := values[i].(*sql.NullString); !ok { - return fmt.Errorf("unexpected type %T for field comment", values[i]) - } else if value.Valid { - u.Comment = value.String - } - case users.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 { - u.CreatedAt = value.Time - } - case users.FieldNext: - if value, ok := values[i].(*sql.NullString); !ok { - return fmt.Errorf("unexpected type %T for field next", values[i]) - } else if value.Valid { - u.Next = value.String - } - case users.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 { - u.UpdatedAt = value.Time - } - case users.FieldURL: - if value, ok := values[i].(*sql.NullString); !ok { - return fmt.Errorf("unexpected type %T for field url", values[i]) - } else if value.Valid { - u.URL = value.String - } - } - } - return nil -} - -// Update returns a builder for updating this Users. -// Note that you need to call Users.Unwrap() before calling this method if this Users -// was returned from a transaction, and the transaction was committed or rolled back. -func (u *Users) Update() *UsersUpdateOne { - return (&UsersClient{config: u.config}).UpdateOne(u) -} - -// Unwrap unwraps the Users 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 (u *Users) Unwrap() *Users { - tx, ok := u.config.driver.(*txDriver) - if !ok { - panic("ent: Users is not a transactional entity") - } - u.config.driver = tx.drv - return u -} - -// String implements the fmt.Stringer. -func (u *Users) String() string { - var builder strings.Builder - builder.WriteString("Users(") - builder.WriteString(fmt.Sprintf("id=%v", u.ID)) - builder.WriteString(", user=") - builder.WriteString(u.User) - builder.WriteString(", chara=") - builder.WriteString(u.Chara) - builder.WriteString(", skill=") - builder.WriteString(fmt.Sprintf("%v", u.Skill)) - builder.WriteString(", hp=") - builder.WriteString(fmt.Sprintf("%v", u.Hp)) - builder.WriteString(", attack=") - builder.WriteString(fmt.Sprintf("%v", u.Attack)) - builder.WriteString(", defense=") - builder.WriteString(fmt.Sprintf("%v", u.Defense)) - builder.WriteString(", critical=") - builder.WriteString(fmt.Sprintf("%v", u.Critical)) - builder.WriteString(", battle=") - builder.WriteString(fmt.Sprintf("%v", u.Battle)) - builder.WriteString(", win=") - builder.WriteString(fmt.Sprintf("%v", u.Win)) - builder.WriteString(", day=") - builder.WriteString(fmt.Sprintf("%v", u.Day)) - builder.WriteString(", percentage=") - builder.WriteString(fmt.Sprintf("%v", u.Percentage)) - builder.WriteString(", limit=") - builder.WriteString(fmt.Sprintf("%v", u.Limit)) - builder.WriteString(", status=") - builder.WriteString(u.Status) - builder.WriteString(", comment=") - builder.WriteString(u.Comment) - builder.WriteString(", created_at=") - builder.WriteString(u.CreatedAt.Format(time.ANSIC)) - builder.WriteString(", next=") - builder.WriteString(u.Next) - builder.WriteString(", updated_at=") - builder.WriteString(u.UpdatedAt.Format(time.ANSIC)) - builder.WriteString(", url=") - builder.WriteString(u.URL) - builder.WriteByte(')') - return builder.String() -} - -// UsersSlice is a parsable slice of Users. -type UsersSlice []*Users - -func (u UsersSlice) config(cfg config) { - for _i := range u { - u[_i].config = cfg - } -} diff --git a/ent/users/users.go b/ent/users/users.go deleted file mode 100644 index 70bb3d0..0000000 --- a/ent/users/users.go +++ /dev/null @@ -1,124 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package users - -import ( - "time" -) - -const ( - // Label holds the string label denoting the users type in the database. - Label = "users" - // FieldID holds the string denoting the id field in the database. - FieldID = "id" - // FieldUser holds the string denoting the user field in the database. - FieldUser = "user" - // FieldChara holds the string denoting the chara field in the database. - FieldChara = "chara" - // FieldSkill holds the string denoting the skill field in the database. - FieldSkill = "skill" - // FieldHp holds the string denoting the hp field in the database. - FieldHp = "hp" - // FieldAttack holds the string denoting the attack field in the database. - FieldAttack = "attack" - // FieldDefense holds the string denoting the defense field in the database. - FieldDefense = "defense" - // FieldCritical holds the string denoting the critical field in the database. - FieldCritical = "critical" - // FieldBattle holds the string denoting the battle field in the database. - FieldBattle = "battle" - // FieldWin holds the string denoting the win field in the database. - FieldWin = "win" - // FieldDay holds the string denoting the day field in the database. - FieldDay = "day" - // FieldPercentage holds the string denoting the percentage field in the database. - FieldPercentage = "percentage" - // FieldLimit holds the string denoting the limit field in the database. - FieldLimit = "limit" - // FieldStatus holds the string denoting the status field in the database. - FieldStatus = "status" - // FieldComment holds the string denoting the comment field in the database. - FieldComment = "comment" - // FieldCreatedAt holds the string denoting the created_at field in the database. - FieldCreatedAt = "created_at" - // FieldNext holds the string denoting the next field in the database. - FieldNext = "next" - // FieldUpdatedAt holds the string denoting the updated_at field in the database. - FieldUpdatedAt = "updated_at" - // FieldURL holds the string denoting the url field in the database. - FieldURL = "url" - // Table holds the table name of the users in the database. - Table = "users" -) - -// Columns holds all SQL columns for users fields. -var Columns = []string{ - FieldID, - FieldUser, - FieldChara, - FieldSkill, - FieldHp, - FieldAttack, - FieldDefense, - FieldCritical, - FieldBattle, - FieldWin, - FieldDay, - FieldPercentage, - FieldLimit, - FieldStatus, - FieldComment, - FieldCreatedAt, - FieldNext, - FieldUpdatedAt, - FieldURL, -} - -// ValidColumn reports if the column name is valid (part of the table columns). -func ValidColumn(column string) bool { - for i := range Columns { - if column == Columns[i] { - return true - } - } - return false -} - -var ( - // UserValidator is a validator for the "user" field. It is called by the builders before save. - UserValidator func(string) error - // DefaultChara holds the default value on creation for the "chara" field. - DefaultChara string - // DefaultSkill holds the default value on creation for the "skill" field. - DefaultSkill int - // DefaultHp holds the default value on creation for the "hp" field. - DefaultHp int - // DefaultAttack holds the default value on creation for the "attack" field. - DefaultAttack int - // DefaultDefense holds the default value on creation for the "defense" field. - DefaultDefense int - // DefaultCritical holds the default value on creation for the "critical" field. - DefaultCritical int - // DefaultBattle holds the default value on creation for the "battle" field. - DefaultBattle int - // DefaultWin holds the default value on creation for the "win" field. - DefaultWin int - // DefaultDay holds the default value on creation for the "day" field. - DefaultDay int - // DefaultPercentage holds the default value on creation for the "percentage" field. - DefaultPercentage float64 - // DefaultLimit holds the default value on creation for the "limit" field. - DefaultLimit bool - // DefaultStatus holds the default value on creation for the "status" field. - DefaultStatus string - // DefaultComment holds the default value on creation for the "comment" field. - DefaultComment string - // DefaultCreatedAt holds the default value on creation for the "created_at" field. - DefaultCreatedAt func() time.Time - // DefaultNext holds the default value on creation for the "next" field. - DefaultNext string - // DefaultUpdatedAt holds the default value on creation for the "updated_at" field. - DefaultUpdatedAt func() time.Time - // DefaultURL holds the default value on creation for the "url" field. - DefaultURL string -) diff --git a/ent/users/where.go b/ent/users/where.go deleted file mode 100644 index 4b36261..0000000 --- a/ent/users/where.go +++ /dev/null @@ -1,2005 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package users - -import ( - "t/ent/predicate" - "time" - - "entgo.io/ent/dialect/sql" -) - -// ID filters vertices based on their ID field. -func ID(id int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldID), id)) - }) -} - -// IDEQ applies the EQ predicate on the ID field. -func IDEQ(id int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldID), id)) - }) -} - -// IDNEQ applies the NEQ predicate on the ID field. -func IDNEQ(id int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldID), id)) - }) -} - -// IDIn applies the In predicate on the ID field. -func IDIn(ids ...int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(ids) == 0 { - s.Where(sql.False()) - return - } - v := make([]interface{}, len(ids)) - for i := range v { - v[i] = ids[i] - } - s.Where(sql.In(s.C(FieldID), v...)) - }) -} - -// IDNotIn applies the NotIn predicate on the ID field. -func IDNotIn(ids ...int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(ids) == 0 { - s.Where(sql.False()) - return - } - v := make([]interface{}, len(ids)) - for i := range v { - v[i] = ids[i] - } - s.Where(sql.NotIn(s.C(FieldID), v...)) - }) -} - -// IDGT applies the GT predicate on the ID field. -func IDGT(id int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldID), id)) - }) -} - -// IDGTE applies the GTE predicate on the ID field. -func IDGTE(id int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldID), id)) - }) -} - -// IDLT applies the LT predicate on the ID field. -func IDLT(id int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldID), id)) - }) -} - -// IDLTE applies the LTE predicate on the ID field. -func IDLTE(id int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldID), id)) - }) -} - -// User applies equality check predicate on the "user" field. It's identical to UserEQ. -func User(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldUser), v)) - }) -} - -// Chara applies equality check predicate on the "chara" field. It's identical to CharaEQ. -func Chara(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldChara), v)) - }) -} - -// Skill applies equality check predicate on the "skill" field. It's identical to SkillEQ. -func Skill(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldSkill), v)) - }) -} - -// Hp applies equality check predicate on the "hp" field. It's identical to HpEQ. -func Hp(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldHp), v)) - }) -} - -// Attack applies equality check predicate on the "attack" field. It's identical to AttackEQ. -func Attack(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldAttack), v)) - }) -} - -// Defense applies equality check predicate on the "defense" field. It's identical to DefenseEQ. -func Defense(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldDefense), v)) - }) -} - -// Critical applies equality check predicate on the "critical" field. It's identical to CriticalEQ. -func Critical(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldCritical), v)) - }) -} - -// Battle applies equality check predicate on the "battle" field. It's identical to BattleEQ. -func Battle(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldBattle), v)) - }) -} - -// Win applies equality check predicate on the "win" field. It's identical to WinEQ. -func Win(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldWin), v)) - }) -} - -// Day applies equality check predicate on the "day" field. It's identical to DayEQ. -func Day(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldDay), v)) - }) -} - -// Percentage applies equality check predicate on the "percentage" field. It's identical to PercentageEQ. -func Percentage(v float64) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldPercentage), v)) - }) -} - -// Limit applies equality check predicate on the "limit" field. It's identical to LimitEQ. -func Limit(v bool) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldLimit), v)) - }) -} - -// Status applies equality check predicate on the "status" field. It's identical to StatusEQ. -func Status(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldStatus), v)) - }) -} - -// Comment applies equality check predicate on the "comment" field. It's identical to CommentEQ. -func Comment(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldComment), v)) - }) -} - -// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ. -func CreatedAt(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldCreatedAt), v)) - }) -} - -// Next applies equality check predicate on the "next" field. It's identical to NextEQ. -func Next(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldNext), v)) - }) -} - -// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ. -func UpdatedAt(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldUpdatedAt), v)) - }) -} - -// URL applies equality check predicate on the "url" field. It's identical to URLEQ. -func URL(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldURL), v)) - }) -} - -// UserEQ applies the EQ predicate on the "user" field. -func UserEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldUser), v)) - }) -} - -// UserNEQ applies the NEQ predicate on the "user" field. -func UserNEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldUser), v)) - }) -} - -// UserIn applies the In predicate on the "user" field. -func UserIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldUser), v...)) - }) -} - -// UserNotIn applies the NotIn predicate on the "user" field. -func UserNotIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldUser), v...)) - }) -} - -// UserGT applies the GT predicate on the "user" field. -func UserGT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldUser), v)) - }) -} - -// UserGTE applies the GTE predicate on the "user" field. -func UserGTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldUser), v)) - }) -} - -// UserLT applies the LT predicate on the "user" field. -func UserLT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldUser), v)) - }) -} - -// UserLTE applies the LTE predicate on the "user" field. -func UserLTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldUser), v)) - }) -} - -// UserContains applies the Contains predicate on the "user" field. -func UserContains(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.Contains(s.C(FieldUser), v)) - }) -} - -// UserHasPrefix applies the HasPrefix predicate on the "user" field. -func UserHasPrefix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasPrefix(s.C(FieldUser), v)) - }) -} - -// UserHasSuffix applies the HasSuffix predicate on the "user" field. -func UserHasSuffix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasSuffix(s.C(FieldUser), v)) - }) -} - -// UserEqualFold applies the EqualFold predicate on the "user" field. -func UserEqualFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EqualFold(s.C(FieldUser), v)) - }) -} - -// UserContainsFold applies the ContainsFold predicate on the "user" field. -func UserContainsFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.ContainsFold(s.C(FieldUser), v)) - }) -} - -// CharaEQ applies the EQ predicate on the "chara" field. -func CharaEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldChara), v)) - }) -} - -// CharaNEQ applies the NEQ predicate on the "chara" field. -func CharaNEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldChara), v)) - }) -} - -// CharaIn applies the In predicate on the "chara" field. -func CharaIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldChara), v...)) - }) -} - -// CharaNotIn applies the NotIn predicate on the "chara" field. -func CharaNotIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldChara), v...)) - }) -} - -// CharaGT applies the GT predicate on the "chara" field. -func CharaGT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldChara), v)) - }) -} - -// CharaGTE applies the GTE predicate on the "chara" field. -func CharaGTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldChara), v)) - }) -} - -// CharaLT applies the LT predicate on the "chara" field. -func CharaLT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldChara), v)) - }) -} - -// CharaLTE applies the LTE predicate on the "chara" field. -func CharaLTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldChara), v)) - }) -} - -// CharaContains applies the Contains predicate on the "chara" field. -func CharaContains(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.Contains(s.C(FieldChara), v)) - }) -} - -// CharaHasPrefix applies the HasPrefix predicate on the "chara" field. -func CharaHasPrefix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasPrefix(s.C(FieldChara), v)) - }) -} - -// CharaHasSuffix applies the HasSuffix predicate on the "chara" field. -func CharaHasSuffix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasSuffix(s.C(FieldChara), v)) - }) -} - -// CharaIsNil applies the IsNil predicate on the "chara" field. -func CharaIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldChara))) - }) -} - -// CharaNotNil applies the NotNil predicate on the "chara" field. -func CharaNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldChara))) - }) -} - -// CharaEqualFold applies the EqualFold predicate on the "chara" field. -func CharaEqualFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EqualFold(s.C(FieldChara), v)) - }) -} - -// CharaContainsFold applies the ContainsFold predicate on the "chara" field. -func CharaContainsFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.ContainsFold(s.C(FieldChara), v)) - }) -} - -// SkillEQ applies the EQ predicate on the "skill" field. -func SkillEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldSkill), v)) - }) -} - -// SkillNEQ applies the NEQ predicate on the "skill" field. -func SkillNEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldSkill), v)) - }) -} - -// SkillIn applies the In predicate on the "skill" field. -func SkillIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldSkill), v...)) - }) -} - -// SkillNotIn applies the NotIn predicate on the "skill" field. -func SkillNotIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldSkill), v...)) - }) -} - -// SkillGT applies the GT predicate on the "skill" field. -func SkillGT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldSkill), v)) - }) -} - -// SkillGTE applies the GTE predicate on the "skill" field. -func SkillGTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldSkill), v)) - }) -} - -// SkillLT applies the LT predicate on the "skill" field. -func SkillLT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldSkill), v)) - }) -} - -// SkillLTE applies the LTE predicate on the "skill" field. -func SkillLTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldSkill), v)) - }) -} - -// SkillIsNil applies the IsNil predicate on the "skill" field. -func SkillIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldSkill))) - }) -} - -// SkillNotNil applies the NotNil predicate on the "skill" field. -func SkillNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldSkill))) - }) -} - -// HpEQ applies the EQ predicate on the "hp" field. -func HpEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldHp), v)) - }) -} - -// HpNEQ applies the NEQ predicate on the "hp" field. -func HpNEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldHp), v)) - }) -} - -// HpIn applies the In predicate on the "hp" field. -func HpIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldHp), v...)) - }) -} - -// HpNotIn applies the NotIn predicate on the "hp" field. -func HpNotIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldHp), v...)) - }) -} - -// HpGT applies the GT predicate on the "hp" field. -func HpGT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldHp), v)) - }) -} - -// HpGTE applies the GTE predicate on the "hp" field. -func HpGTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldHp), v)) - }) -} - -// HpLT applies the LT predicate on the "hp" field. -func HpLT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldHp), v)) - }) -} - -// HpLTE applies the LTE predicate on the "hp" field. -func HpLTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldHp), v)) - }) -} - -// HpIsNil applies the IsNil predicate on the "hp" field. -func HpIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldHp))) - }) -} - -// HpNotNil applies the NotNil predicate on the "hp" field. -func HpNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldHp))) - }) -} - -// AttackEQ applies the EQ predicate on the "attack" field. -func AttackEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldAttack), v)) - }) -} - -// AttackNEQ applies the NEQ predicate on the "attack" field. -func AttackNEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldAttack), v)) - }) -} - -// AttackIn applies the In predicate on the "attack" field. -func AttackIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldAttack), v...)) - }) -} - -// AttackNotIn applies the NotIn predicate on the "attack" field. -func AttackNotIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldAttack), v...)) - }) -} - -// AttackGT applies the GT predicate on the "attack" field. -func AttackGT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldAttack), v)) - }) -} - -// AttackGTE applies the GTE predicate on the "attack" field. -func AttackGTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldAttack), v)) - }) -} - -// AttackLT applies the LT predicate on the "attack" field. -func AttackLT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldAttack), v)) - }) -} - -// AttackLTE applies the LTE predicate on the "attack" field. -func AttackLTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldAttack), v)) - }) -} - -// AttackIsNil applies the IsNil predicate on the "attack" field. -func AttackIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldAttack))) - }) -} - -// AttackNotNil applies the NotNil predicate on the "attack" field. -func AttackNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldAttack))) - }) -} - -// DefenseEQ applies the EQ predicate on the "defense" field. -func DefenseEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldDefense), v)) - }) -} - -// DefenseNEQ applies the NEQ predicate on the "defense" field. -func DefenseNEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldDefense), v)) - }) -} - -// DefenseIn applies the In predicate on the "defense" field. -func DefenseIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldDefense), v...)) - }) -} - -// DefenseNotIn applies the NotIn predicate on the "defense" field. -func DefenseNotIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldDefense), v...)) - }) -} - -// DefenseGT applies the GT predicate on the "defense" field. -func DefenseGT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldDefense), v)) - }) -} - -// DefenseGTE applies the GTE predicate on the "defense" field. -func DefenseGTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldDefense), v)) - }) -} - -// DefenseLT applies the LT predicate on the "defense" field. -func DefenseLT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldDefense), v)) - }) -} - -// DefenseLTE applies the LTE predicate on the "defense" field. -func DefenseLTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldDefense), v)) - }) -} - -// DefenseIsNil applies the IsNil predicate on the "defense" field. -func DefenseIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldDefense))) - }) -} - -// DefenseNotNil applies the NotNil predicate on the "defense" field. -func DefenseNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldDefense))) - }) -} - -// CriticalEQ applies the EQ predicate on the "critical" field. -func CriticalEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldCritical), v)) - }) -} - -// CriticalNEQ applies the NEQ predicate on the "critical" field. -func CriticalNEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldCritical), v)) - }) -} - -// CriticalIn applies the In predicate on the "critical" field. -func CriticalIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldCritical), v...)) - }) -} - -// CriticalNotIn applies the NotIn predicate on the "critical" field. -func CriticalNotIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldCritical), v...)) - }) -} - -// CriticalGT applies the GT predicate on the "critical" field. -func CriticalGT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldCritical), v)) - }) -} - -// CriticalGTE applies the GTE predicate on the "critical" field. -func CriticalGTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldCritical), v)) - }) -} - -// CriticalLT applies the LT predicate on the "critical" field. -func CriticalLT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldCritical), v)) - }) -} - -// CriticalLTE applies the LTE predicate on the "critical" field. -func CriticalLTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldCritical), v)) - }) -} - -// CriticalIsNil applies the IsNil predicate on the "critical" field. -func CriticalIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldCritical))) - }) -} - -// CriticalNotNil applies the NotNil predicate on the "critical" field. -func CriticalNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldCritical))) - }) -} - -// BattleEQ applies the EQ predicate on the "battle" field. -func BattleEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldBattle), v)) - }) -} - -// BattleNEQ applies the NEQ predicate on the "battle" field. -func BattleNEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldBattle), v)) - }) -} - -// BattleIn applies the In predicate on the "battle" field. -func BattleIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldBattle), v...)) - }) -} - -// BattleNotIn applies the NotIn predicate on the "battle" field. -func BattleNotIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldBattle), v...)) - }) -} - -// BattleGT applies the GT predicate on the "battle" field. -func BattleGT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldBattle), v)) - }) -} - -// BattleGTE applies the GTE predicate on the "battle" field. -func BattleGTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldBattle), v)) - }) -} - -// BattleLT applies the LT predicate on the "battle" field. -func BattleLT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldBattle), v)) - }) -} - -// BattleLTE applies the LTE predicate on the "battle" field. -func BattleLTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldBattle), v)) - }) -} - -// BattleIsNil applies the IsNil predicate on the "battle" field. -func BattleIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldBattle))) - }) -} - -// BattleNotNil applies the NotNil predicate on the "battle" field. -func BattleNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldBattle))) - }) -} - -// WinEQ applies the EQ predicate on the "win" field. -func WinEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldWin), v)) - }) -} - -// WinNEQ applies the NEQ predicate on the "win" field. -func WinNEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldWin), v)) - }) -} - -// WinIn applies the In predicate on the "win" field. -func WinIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldWin), v...)) - }) -} - -// WinNotIn applies the NotIn predicate on the "win" field. -func WinNotIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldWin), v...)) - }) -} - -// WinGT applies the GT predicate on the "win" field. -func WinGT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldWin), v)) - }) -} - -// WinGTE applies the GTE predicate on the "win" field. -func WinGTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldWin), v)) - }) -} - -// WinLT applies the LT predicate on the "win" field. -func WinLT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldWin), v)) - }) -} - -// WinLTE applies the LTE predicate on the "win" field. -func WinLTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldWin), v)) - }) -} - -// WinIsNil applies the IsNil predicate on the "win" field. -func WinIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldWin))) - }) -} - -// WinNotNil applies the NotNil predicate on the "win" field. -func WinNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldWin))) - }) -} - -// DayEQ applies the EQ predicate on the "day" field. -func DayEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldDay), v)) - }) -} - -// DayNEQ applies the NEQ predicate on the "day" field. -func DayNEQ(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldDay), v)) - }) -} - -// DayIn applies the In predicate on the "day" field. -func DayIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldDay), v...)) - }) -} - -// DayNotIn applies the NotIn predicate on the "day" field. -func DayNotIn(vs ...int) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldDay), v...)) - }) -} - -// DayGT applies the GT predicate on the "day" field. -func DayGT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldDay), v)) - }) -} - -// DayGTE applies the GTE predicate on the "day" field. -func DayGTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldDay), v)) - }) -} - -// DayLT applies the LT predicate on the "day" field. -func DayLT(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldDay), v)) - }) -} - -// DayLTE applies the LTE predicate on the "day" field. -func DayLTE(v int) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldDay), v)) - }) -} - -// DayIsNil applies the IsNil predicate on the "day" field. -func DayIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldDay))) - }) -} - -// DayNotNil applies the NotNil predicate on the "day" field. -func DayNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldDay))) - }) -} - -// PercentageEQ applies the EQ predicate on the "percentage" field. -func PercentageEQ(v float64) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldPercentage), v)) - }) -} - -// PercentageNEQ applies the NEQ predicate on the "percentage" field. -func PercentageNEQ(v float64) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldPercentage), v)) - }) -} - -// PercentageIn applies the In predicate on the "percentage" field. -func PercentageIn(vs ...float64) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldPercentage), v...)) - }) -} - -// PercentageNotIn applies the NotIn predicate on the "percentage" field. -func PercentageNotIn(vs ...float64) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldPercentage), v...)) - }) -} - -// PercentageGT applies the GT predicate on the "percentage" field. -func PercentageGT(v float64) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldPercentage), v)) - }) -} - -// PercentageGTE applies the GTE predicate on the "percentage" field. -func PercentageGTE(v float64) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldPercentage), v)) - }) -} - -// PercentageLT applies the LT predicate on the "percentage" field. -func PercentageLT(v float64) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldPercentage), v)) - }) -} - -// PercentageLTE applies the LTE predicate on the "percentage" field. -func PercentageLTE(v float64) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldPercentage), v)) - }) -} - -// PercentageIsNil applies the IsNil predicate on the "percentage" field. -func PercentageIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldPercentage))) - }) -} - -// PercentageNotNil applies the NotNil predicate on the "percentage" field. -func PercentageNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldPercentage))) - }) -} - -// LimitEQ applies the EQ predicate on the "limit" field. -func LimitEQ(v bool) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldLimit), v)) - }) -} - -// LimitNEQ applies the NEQ predicate on the "limit" field. -func LimitNEQ(v bool) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldLimit), v)) - }) -} - -// LimitIsNil applies the IsNil predicate on the "limit" field. -func LimitIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldLimit))) - }) -} - -// LimitNotNil applies the NotNil predicate on the "limit" field. -func LimitNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldLimit))) - }) -} - -// StatusEQ applies the EQ predicate on the "status" field. -func StatusEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldStatus), v)) - }) -} - -// StatusNEQ applies the NEQ predicate on the "status" field. -func StatusNEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldStatus), v)) - }) -} - -// StatusIn applies the In predicate on the "status" field. -func StatusIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldStatus), v...)) - }) -} - -// StatusNotIn applies the NotIn predicate on the "status" field. -func StatusNotIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldStatus), v...)) - }) -} - -// StatusGT applies the GT predicate on the "status" field. -func StatusGT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldStatus), v)) - }) -} - -// StatusGTE applies the GTE predicate on the "status" field. -func StatusGTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldStatus), v)) - }) -} - -// StatusLT applies the LT predicate on the "status" field. -func StatusLT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldStatus), v)) - }) -} - -// StatusLTE applies the LTE predicate on the "status" field. -func StatusLTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldStatus), v)) - }) -} - -// StatusContains applies the Contains predicate on the "status" field. -func StatusContains(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.Contains(s.C(FieldStatus), v)) - }) -} - -// StatusHasPrefix applies the HasPrefix predicate on the "status" field. -func StatusHasPrefix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasPrefix(s.C(FieldStatus), v)) - }) -} - -// StatusHasSuffix applies the HasSuffix predicate on the "status" field. -func StatusHasSuffix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasSuffix(s.C(FieldStatus), v)) - }) -} - -// StatusIsNil applies the IsNil predicate on the "status" field. -func StatusIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldStatus))) - }) -} - -// StatusNotNil applies the NotNil predicate on the "status" field. -func StatusNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldStatus))) - }) -} - -// StatusEqualFold applies the EqualFold predicate on the "status" field. -func StatusEqualFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EqualFold(s.C(FieldStatus), v)) - }) -} - -// StatusContainsFold applies the ContainsFold predicate on the "status" field. -func StatusContainsFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.ContainsFold(s.C(FieldStatus), v)) - }) -} - -// CommentEQ applies the EQ predicate on the "comment" field. -func CommentEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldComment), v)) - }) -} - -// CommentNEQ applies the NEQ predicate on the "comment" field. -func CommentNEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldComment), v)) - }) -} - -// CommentIn applies the In predicate on the "comment" field. -func CommentIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldComment), v...)) - }) -} - -// CommentNotIn applies the NotIn predicate on the "comment" field. -func CommentNotIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldComment), v...)) - }) -} - -// CommentGT applies the GT predicate on the "comment" field. -func CommentGT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldComment), v)) - }) -} - -// CommentGTE applies the GTE predicate on the "comment" field. -func CommentGTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldComment), v)) - }) -} - -// CommentLT applies the LT predicate on the "comment" field. -func CommentLT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldComment), v)) - }) -} - -// CommentLTE applies the LTE predicate on the "comment" field. -func CommentLTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldComment), v)) - }) -} - -// CommentContains applies the Contains predicate on the "comment" field. -func CommentContains(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.Contains(s.C(FieldComment), v)) - }) -} - -// CommentHasPrefix applies the HasPrefix predicate on the "comment" field. -func CommentHasPrefix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasPrefix(s.C(FieldComment), v)) - }) -} - -// CommentHasSuffix applies the HasSuffix predicate on the "comment" field. -func CommentHasSuffix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasSuffix(s.C(FieldComment), v)) - }) -} - -// CommentIsNil applies the IsNil predicate on the "comment" field. -func CommentIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldComment))) - }) -} - -// CommentNotNil applies the NotNil predicate on the "comment" field. -func CommentNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldComment))) - }) -} - -// CommentEqualFold applies the EqualFold predicate on the "comment" field. -func CommentEqualFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EqualFold(s.C(FieldComment), v)) - }) -} - -// CommentContainsFold applies the ContainsFold predicate on the "comment" field. -func CommentContainsFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.ContainsFold(s.C(FieldComment), v)) - }) -} - -// CreatedAtEQ applies the EQ predicate on the "created_at" field. -func CreatedAtEQ(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldCreatedAt), v)) - }) -} - -// CreatedAtNEQ applies the NEQ predicate on the "created_at" field. -func CreatedAtNEQ(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldCreatedAt), v)) - }) -} - -// CreatedAtIn applies the In predicate on the "created_at" field. -func CreatedAtIn(vs ...time.Time) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldCreatedAt), v...)) - }) -} - -// CreatedAtNotIn applies the NotIn predicate on the "created_at" field. -func CreatedAtNotIn(vs ...time.Time) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldCreatedAt), v...)) - }) -} - -// CreatedAtGT applies the GT predicate on the "created_at" field. -func CreatedAtGT(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldCreatedAt), v)) - }) -} - -// CreatedAtGTE applies the GTE predicate on the "created_at" field. -func CreatedAtGTE(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldCreatedAt), v)) - }) -} - -// CreatedAtLT applies the LT predicate on the "created_at" field. -func CreatedAtLT(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldCreatedAt), v)) - }) -} - -// CreatedAtLTE applies the LTE predicate on the "created_at" field. -func CreatedAtLTE(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldCreatedAt), v)) - }) -} - -// CreatedAtIsNil applies the IsNil predicate on the "created_at" field. -func CreatedAtIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldCreatedAt))) - }) -} - -// CreatedAtNotNil applies the NotNil predicate on the "created_at" field. -func CreatedAtNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldCreatedAt))) - }) -} - -// NextEQ applies the EQ predicate on the "next" field. -func NextEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldNext), v)) - }) -} - -// NextNEQ applies the NEQ predicate on the "next" field. -func NextNEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldNext), v)) - }) -} - -// NextIn applies the In predicate on the "next" field. -func NextIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldNext), v...)) - }) -} - -// NextNotIn applies the NotIn predicate on the "next" field. -func NextNotIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldNext), v...)) - }) -} - -// NextGT applies the GT predicate on the "next" field. -func NextGT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldNext), v)) - }) -} - -// NextGTE applies the GTE predicate on the "next" field. -func NextGTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldNext), v)) - }) -} - -// NextLT applies the LT predicate on the "next" field. -func NextLT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldNext), v)) - }) -} - -// NextLTE applies the LTE predicate on the "next" field. -func NextLTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldNext), v)) - }) -} - -// NextContains applies the Contains predicate on the "next" field. -func NextContains(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.Contains(s.C(FieldNext), v)) - }) -} - -// NextHasPrefix applies the HasPrefix predicate on the "next" field. -func NextHasPrefix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasPrefix(s.C(FieldNext), v)) - }) -} - -// NextHasSuffix applies the HasSuffix predicate on the "next" field. -func NextHasSuffix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasSuffix(s.C(FieldNext), v)) - }) -} - -// NextIsNil applies the IsNil predicate on the "next" field. -func NextIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldNext))) - }) -} - -// NextNotNil applies the NotNil predicate on the "next" field. -func NextNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldNext))) - }) -} - -// NextEqualFold applies the EqualFold predicate on the "next" field. -func NextEqualFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EqualFold(s.C(FieldNext), v)) - }) -} - -// NextContainsFold applies the ContainsFold predicate on the "next" field. -func NextContainsFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.ContainsFold(s.C(FieldNext), v)) - }) -} - -// UpdatedAtEQ applies the EQ predicate on the "updated_at" field. -func UpdatedAtEQ(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldUpdatedAt), v)) - }) -} - -// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field. -func UpdatedAtNEQ(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldUpdatedAt), v)) - }) -} - -// UpdatedAtIn applies the In predicate on the "updated_at" field. -func UpdatedAtIn(vs ...time.Time) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldUpdatedAt), v...)) - }) -} - -// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field. -func UpdatedAtNotIn(vs ...time.Time) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldUpdatedAt), v...)) - }) -} - -// UpdatedAtGT applies the GT predicate on the "updated_at" field. -func UpdatedAtGT(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldUpdatedAt), v)) - }) -} - -// UpdatedAtGTE applies the GTE predicate on the "updated_at" field. -func UpdatedAtGTE(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldUpdatedAt), v)) - }) -} - -// UpdatedAtLT applies the LT predicate on the "updated_at" field. -func UpdatedAtLT(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldUpdatedAt), v)) - }) -} - -// UpdatedAtLTE applies the LTE predicate on the "updated_at" field. -func UpdatedAtLTE(v time.Time) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldUpdatedAt), v)) - }) -} - -// UpdatedAtIsNil applies the IsNil predicate on the "updated_at" field. -func UpdatedAtIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldUpdatedAt))) - }) -} - -// UpdatedAtNotNil applies the NotNil predicate on the "updated_at" field. -func UpdatedAtNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldUpdatedAt))) - }) -} - -// URLEQ applies the EQ predicate on the "url" field. -func URLEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EQ(s.C(FieldURL), v)) - }) -} - -// URLNEQ applies the NEQ predicate on the "url" field. -func URLNEQ(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NEQ(s.C(FieldURL), v)) - }) -} - -// URLIn applies the In predicate on the "url" field. -func URLIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.In(s.C(FieldURL), v...)) - }) -} - -// URLNotIn applies the NotIn predicate on the "url" field. -func URLNotIn(vs ...string) predicate.Users { - v := make([]interface{}, len(vs)) - for i := range v { - v[i] = vs[i] - } - return predicate.Users(func(s *sql.Selector) { - // if not arguments were provided, append the FALSE constants, - // since we can't apply "IN ()". This will make this predicate falsy. - if len(v) == 0 { - s.Where(sql.False()) - return - } - s.Where(sql.NotIn(s.C(FieldURL), v...)) - }) -} - -// URLGT applies the GT predicate on the "url" field. -func URLGT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GT(s.C(FieldURL), v)) - }) -} - -// URLGTE applies the GTE predicate on the "url" field. -func URLGTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.GTE(s.C(FieldURL), v)) - }) -} - -// URLLT applies the LT predicate on the "url" field. -func URLLT(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LT(s.C(FieldURL), v)) - }) -} - -// URLLTE applies the LTE predicate on the "url" field. -func URLLTE(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.LTE(s.C(FieldURL), v)) - }) -} - -// URLContains applies the Contains predicate on the "url" field. -func URLContains(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.Contains(s.C(FieldURL), v)) - }) -} - -// URLHasPrefix applies the HasPrefix predicate on the "url" field. -func URLHasPrefix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasPrefix(s.C(FieldURL), v)) - }) -} - -// URLHasSuffix applies the HasSuffix predicate on the "url" field. -func URLHasSuffix(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.HasSuffix(s.C(FieldURL), v)) - }) -} - -// URLIsNil applies the IsNil predicate on the "url" field. -func URLIsNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.IsNull(s.C(FieldURL))) - }) -} - -// URLNotNil applies the NotNil predicate on the "url" field. -func URLNotNil() predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.NotNull(s.C(FieldURL))) - }) -} - -// URLEqualFold applies the EqualFold predicate on the "url" field. -func URLEqualFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.EqualFold(s.C(FieldURL), v)) - }) -} - -// URLContainsFold applies the ContainsFold predicate on the "url" field. -func URLContainsFold(v string) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - s.Where(sql.ContainsFold(s.C(FieldURL), v)) - }) -} - -// And groups predicates with the AND operator between them. -func And(predicates ...predicate.Users) predicate.Users { - return predicate.Users(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.Users) predicate.Users { - return predicate.Users(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.Users) predicate.Users { - return predicate.Users(func(s *sql.Selector) { - p(s.Not()) - }) -} diff --git a/ent/users_create.go b/ent/users_create.go deleted file mode 100644 index ee58b08..0000000 --- a/ent/users_create.go +++ /dev/null @@ -1,674 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package ent - -import ( - "context" - "errors" - "fmt" - "t/ent/users" - "time" - - "entgo.io/ent/dialect/sql/sqlgraph" - "entgo.io/ent/schema/field" -) - -// UsersCreate is the builder for creating a Users entity. -type UsersCreate struct { - config - mutation *UsersMutation - hooks []Hook -} - -// SetUser sets the "user" field. -func (uc *UsersCreate) SetUser(s string) *UsersCreate { - uc.mutation.SetUser(s) - return uc -} - -// SetChara sets the "chara" field. -func (uc *UsersCreate) SetChara(s string) *UsersCreate { - uc.mutation.SetChara(s) - return uc -} - -// SetNillableChara sets the "chara" field if the given value is not nil. -func (uc *UsersCreate) SetNillableChara(s *string) *UsersCreate { - if s != nil { - uc.SetChara(*s) - } - return uc -} - -// SetSkill sets the "skill" field. -func (uc *UsersCreate) SetSkill(i int) *UsersCreate { - uc.mutation.SetSkill(i) - return uc -} - -// SetNillableSkill sets the "skill" field if the given value is not nil. -func (uc *UsersCreate) SetNillableSkill(i *int) *UsersCreate { - if i != nil { - uc.SetSkill(*i) - } - return uc -} - -// SetHp sets the "hp" field. -func (uc *UsersCreate) SetHp(i int) *UsersCreate { - uc.mutation.SetHp(i) - return uc -} - -// SetNillableHp sets the "hp" field if the given value is not nil. -func (uc *UsersCreate) SetNillableHp(i *int) *UsersCreate { - if i != nil { - uc.SetHp(*i) - } - return uc -} - -// SetAttack sets the "attack" field. -func (uc *UsersCreate) SetAttack(i int) *UsersCreate { - uc.mutation.SetAttack(i) - return uc -} - -// SetNillableAttack sets the "attack" field if the given value is not nil. -func (uc *UsersCreate) SetNillableAttack(i *int) *UsersCreate { - if i != nil { - uc.SetAttack(*i) - } - return uc -} - -// SetDefense sets the "defense" field. -func (uc *UsersCreate) SetDefense(i int) *UsersCreate { - uc.mutation.SetDefense(i) - return uc -} - -// SetNillableDefense sets the "defense" field if the given value is not nil. -func (uc *UsersCreate) SetNillableDefense(i *int) *UsersCreate { - if i != nil { - uc.SetDefense(*i) - } - return uc -} - -// SetCritical sets the "critical" field. -func (uc *UsersCreate) SetCritical(i int) *UsersCreate { - uc.mutation.SetCritical(i) - return uc -} - -// SetNillableCritical sets the "critical" field if the given value is not nil. -func (uc *UsersCreate) SetNillableCritical(i *int) *UsersCreate { - if i != nil { - uc.SetCritical(*i) - } - return uc -} - -// SetBattle sets the "battle" field. -func (uc *UsersCreate) SetBattle(i int) *UsersCreate { - uc.mutation.SetBattle(i) - return uc -} - -// SetNillableBattle sets the "battle" field if the given value is not nil. -func (uc *UsersCreate) SetNillableBattle(i *int) *UsersCreate { - if i != nil { - uc.SetBattle(*i) - } - return uc -} - -// SetWin sets the "win" field. -func (uc *UsersCreate) SetWin(i int) *UsersCreate { - uc.mutation.SetWin(i) - return uc -} - -// SetNillableWin sets the "win" field if the given value is not nil. -func (uc *UsersCreate) SetNillableWin(i *int) *UsersCreate { - if i != nil { - uc.SetWin(*i) - } - return uc -} - -// SetDay sets the "day" field. -func (uc *UsersCreate) SetDay(i int) *UsersCreate { - uc.mutation.SetDay(i) - return uc -} - -// SetNillableDay sets the "day" field if the given value is not nil. -func (uc *UsersCreate) SetNillableDay(i *int) *UsersCreate { - if i != nil { - uc.SetDay(*i) - } - return uc -} - -// SetPercentage sets the "percentage" field. -func (uc *UsersCreate) SetPercentage(f float64) *UsersCreate { - uc.mutation.SetPercentage(f) - return uc -} - -// SetNillablePercentage sets the "percentage" field if the given value is not nil. -func (uc *UsersCreate) SetNillablePercentage(f *float64) *UsersCreate { - if f != nil { - uc.SetPercentage(*f) - } - return uc -} - -// SetLimit sets the "limit" field. -func (uc *UsersCreate) SetLimit(b bool) *UsersCreate { - uc.mutation.SetLimit(b) - return uc -} - -// SetNillableLimit sets the "limit" field if the given value is not nil. -func (uc *UsersCreate) SetNillableLimit(b *bool) *UsersCreate { - if b != nil { - uc.SetLimit(*b) - } - return uc -} - -// SetStatus sets the "status" field. -func (uc *UsersCreate) SetStatus(s string) *UsersCreate { - uc.mutation.SetStatus(s) - return uc -} - -// SetNillableStatus sets the "status" field if the given value is not nil. -func (uc *UsersCreate) SetNillableStatus(s *string) *UsersCreate { - if s != nil { - uc.SetStatus(*s) - } - return uc -} - -// SetComment sets the "comment" field. -func (uc *UsersCreate) SetComment(s string) *UsersCreate { - uc.mutation.SetComment(s) - return uc -} - -// SetNillableComment sets the "comment" field if the given value is not nil. -func (uc *UsersCreate) SetNillableComment(s *string) *UsersCreate { - if s != nil { - uc.SetComment(*s) - } - return uc -} - -// SetCreatedAt sets the "created_at" field. -func (uc *UsersCreate) SetCreatedAt(t time.Time) *UsersCreate { - uc.mutation.SetCreatedAt(t) - return uc -} - -// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. -func (uc *UsersCreate) SetNillableCreatedAt(t *time.Time) *UsersCreate { - if t != nil { - uc.SetCreatedAt(*t) - } - return uc -} - -// SetNext sets the "next" field. -func (uc *UsersCreate) SetNext(s string) *UsersCreate { - uc.mutation.SetNext(s) - return uc -} - -// SetNillableNext sets the "next" field if the given value is not nil. -func (uc *UsersCreate) SetNillableNext(s *string) *UsersCreate { - if s != nil { - uc.SetNext(*s) - } - return uc -} - -// SetUpdatedAt sets the "updated_at" field. -func (uc *UsersCreate) SetUpdatedAt(t time.Time) *UsersCreate { - uc.mutation.SetUpdatedAt(t) - return uc -} - -// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. -func (uc *UsersCreate) SetNillableUpdatedAt(t *time.Time) *UsersCreate { - if t != nil { - uc.SetUpdatedAt(*t) - } - return uc -} - -// SetURL sets the "url" field. -func (uc *UsersCreate) SetURL(s string) *UsersCreate { - uc.mutation.SetURL(s) - return uc -} - -// SetNillableURL sets the "url" field if the given value is not nil. -func (uc *UsersCreate) SetNillableURL(s *string) *UsersCreate { - if s != nil { - uc.SetURL(*s) - } - return uc -} - -// Mutation returns the UsersMutation object of the builder. -func (uc *UsersCreate) Mutation() *UsersMutation { - return uc.mutation -} - -// Save creates the Users in the database. -func (uc *UsersCreate) Save(ctx context.Context) (*Users, error) { - var ( - err error - node *Users - ) - uc.defaults() - if len(uc.hooks) == 0 { - if err = uc.check(); err != nil { - return nil, err - } - node, err = uc.sqlSave(ctx) - } else { - var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { - mutation, ok := m.(*UsersMutation) - if !ok { - return nil, fmt.Errorf("unexpected mutation type %T", m) - } - if err = uc.check(); err != nil { - return nil, err - } - uc.mutation = mutation - if node, err = uc.sqlSave(ctx); err != nil { - return nil, err - } - mutation.id = &node.ID - mutation.done = true - return node, err - }) - for i := len(uc.hooks) - 1; i >= 0; i-- { - if uc.hooks[i] == nil { - return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)") - } - mut = uc.hooks[i](mut) - } - if _, err := mut.Mutate(ctx, uc.mutation); err != nil { - return nil, err - } - } - return node, err -} - -// SaveX calls Save and panics if Save returns an error. -func (uc *UsersCreate) SaveX(ctx context.Context) *Users { - v, err := uc.Save(ctx) - if err != nil { - panic(err) - } - return v -} - -// Exec executes the query. -func (uc *UsersCreate) Exec(ctx context.Context) error { - _, err := uc.Save(ctx) - return err -} - -// ExecX is like Exec, but panics if an error occurs. -func (uc *UsersCreate) ExecX(ctx context.Context) { - if err := uc.Exec(ctx); err != nil { - panic(err) - } -} - -// defaults sets the default values of the builder before save. -func (uc *UsersCreate) defaults() { - if _, ok := uc.mutation.Chara(); !ok { - v := users.DefaultChara - uc.mutation.SetChara(v) - } - if _, ok := uc.mutation.Skill(); !ok { - v := users.DefaultSkill - uc.mutation.SetSkill(v) - } - if _, ok := uc.mutation.Hp(); !ok { - v := users.DefaultHp - uc.mutation.SetHp(v) - } - if _, ok := uc.mutation.Attack(); !ok { - v := users.DefaultAttack - uc.mutation.SetAttack(v) - } - if _, ok := uc.mutation.Defense(); !ok { - v := users.DefaultDefense - uc.mutation.SetDefense(v) - } - if _, ok := uc.mutation.Critical(); !ok { - v := users.DefaultCritical - uc.mutation.SetCritical(v) - } - if _, ok := uc.mutation.Battle(); !ok { - v := users.DefaultBattle - uc.mutation.SetBattle(v) - } - if _, ok := uc.mutation.Win(); !ok { - v := users.DefaultWin - uc.mutation.SetWin(v) - } - if _, ok := uc.mutation.Day(); !ok { - v := users.DefaultDay - uc.mutation.SetDay(v) - } - if _, ok := uc.mutation.Percentage(); !ok { - v := users.DefaultPercentage - uc.mutation.SetPercentage(v) - } - if _, ok := uc.mutation.Limit(); !ok { - v := users.DefaultLimit - uc.mutation.SetLimit(v) - } - if _, ok := uc.mutation.Status(); !ok { - v := users.DefaultStatus - uc.mutation.SetStatus(v) - } - if _, ok := uc.mutation.Comment(); !ok { - v := users.DefaultComment - uc.mutation.SetComment(v) - } - if _, ok := uc.mutation.CreatedAt(); !ok { - v := users.DefaultCreatedAt() - uc.mutation.SetCreatedAt(v) - } - if _, ok := uc.mutation.Next(); !ok { - v := users.DefaultNext - uc.mutation.SetNext(v) - } - if _, ok := uc.mutation.UpdatedAt(); !ok { - v := users.DefaultUpdatedAt() - uc.mutation.SetUpdatedAt(v) - } - if _, ok := uc.mutation.URL(); !ok { - v := users.DefaultURL - uc.mutation.SetURL(v) - } -} - -// check runs all checks and user-defined validators on the builder. -func (uc *UsersCreate) check() error { - if _, ok := uc.mutation.User(); !ok { - return &ValidationError{Name: "user", err: errors.New(`ent: missing required field "Users.user"`)} - } - if v, ok := uc.mutation.User(); ok { - if err := users.UserValidator(v); err != nil { - return &ValidationError{Name: "user", err: fmt.Errorf(`ent: validator failed for field "Users.user": %w`, err)} - } - } - return nil -} - -func (uc *UsersCreate) sqlSave(ctx context.Context) (*Users, error) { - _node, _spec := uc.createSpec() - if err := sqlgraph.CreateNode(ctx, uc.driver, _spec); err != nil { - if sqlgraph.IsConstraintError(err) { - err = &ConstraintError{err.Error(), err} - } - return nil, err - } - id := _spec.ID.Value.(int64) - _node.ID = int(id) - return _node, nil -} - -func (uc *UsersCreate) createSpec() (*Users, *sqlgraph.CreateSpec) { - var ( - _node = &Users{config: uc.config} - _spec = &sqlgraph.CreateSpec{ - Table: users.Table, - ID: &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldID, - }, - } - ) - if value, ok := uc.mutation.User(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Value: value, - Column: users.FieldUser, - }) - _node.User = value - } - if value, ok := uc.mutation.Chara(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Value: value, - Column: users.FieldChara, - }) - _node.Chara = value - } - if value, ok := uc.mutation.Skill(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldSkill, - }) - _node.Skill = value - } - if value, ok := uc.mutation.Hp(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldHp, - }) - _node.Hp = value - } - if value, ok := uc.mutation.Attack(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldAttack, - }) - _node.Attack = value - } - if value, ok := uc.mutation.Defense(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldDefense, - }) - _node.Defense = value - } - if value, ok := uc.mutation.Critical(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldCritical, - }) - _node.Critical = value - } - if value, ok := uc.mutation.Battle(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldBattle, - }) - _node.Battle = value - } - if value, ok := uc.mutation.Win(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldWin, - }) - _node.Win = value - } - if value, ok := uc.mutation.Day(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldDay, - }) - _node.Day = value - } - if value, ok := uc.mutation.Percentage(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeFloat64, - Value: value, - Column: users.FieldPercentage, - }) - _node.Percentage = value - } - if value, ok := uc.mutation.Limit(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeBool, - Value: value, - Column: users.FieldLimit, - }) - _node.Limit = value - } - if value, ok := uc.mutation.Status(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Value: value, - Column: users.FieldStatus, - }) - _node.Status = value - } - if value, ok := uc.mutation.Comment(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Value: value, - Column: users.FieldComment, - }) - _node.Comment = value - } - if value, ok := uc.mutation.CreatedAt(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeTime, - Value: value, - Column: users.FieldCreatedAt, - }) - _node.CreatedAt = value - } - if value, ok := uc.mutation.Next(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Value: value, - Column: users.FieldNext, - }) - _node.Next = value - } - if value, ok := uc.mutation.UpdatedAt(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeTime, - Value: value, - Column: users.FieldUpdatedAt, - }) - _node.UpdatedAt = value - } - if value, ok := uc.mutation.URL(); ok { - _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Value: value, - Column: users.FieldURL, - }) - _node.URL = value - } - return _node, _spec -} - -// UsersCreateBulk is the builder for creating many Users entities in bulk. -type UsersCreateBulk struct { - config - builders []*UsersCreate -} - -// Save creates the Users entities in the database. -func (ucb *UsersCreateBulk) Save(ctx context.Context) ([]*Users, error) { - specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) - nodes := make([]*Users, len(ucb.builders)) - mutators := make([]Mutator, len(ucb.builders)) - for i := range ucb.builders { - func(i int, root context.Context) { - builder := ucb.builders[i] - builder.defaults() - var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { - mutation, ok := m.(*UsersMutation) - if !ok { - return nil, fmt.Errorf("unexpected mutation type %T", m) - } - if err := builder.check(); err != nil { - return nil, err - } - builder.mutation = mutation - nodes[i], specs[i] = builder.createSpec() - var err error - if i < len(mutators)-1 { - _, err = mutators[i+1].Mutate(root, ucb.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, ucb.driver, spec); err != nil { - if sqlgraph.IsConstraintError(err) { - err = &ConstraintError{err.Error(), err} - } - } - } - if err != nil { - return nil, err - } - mutation.id = &nodes[i].ID - mutation.done = true - if specs[i].ID.Value != nil { - id := specs[i].ID.Value.(int64) - nodes[i].ID = int(id) - } - 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, ucb.builders[0].mutation); err != nil { - return nil, err - } - } - return nodes, nil -} - -// SaveX is like Save, but panics if an error occurs. -func (ucb *UsersCreateBulk) SaveX(ctx context.Context) []*Users { - v, err := ucb.Save(ctx) - if err != nil { - panic(err) - } - return v -} - -// Exec executes the query. -func (ucb *UsersCreateBulk) Exec(ctx context.Context) error { - _, err := ucb.Save(ctx) - return err -} - -// ExecX is like Exec, but panics if an error occurs. -func (ucb *UsersCreateBulk) ExecX(ctx context.Context) { - if err := ucb.Exec(ctx); err != nil { - panic(err) - } -} diff --git a/ent/users_delete.go b/ent/users_delete.go deleted file mode 100644 index 662c450..0000000 --- a/ent/users_delete.go +++ /dev/null @@ -1,111 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package ent - -import ( - "context" - "fmt" - "t/ent/predicate" - "t/ent/users" - - "entgo.io/ent/dialect/sql" - "entgo.io/ent/dialect/sql/sqlgraph" - "entgo.io/ent/schema/field" -) - -// UsersDelete is the builder for deleting a Users entity. -type UsersDelete struct { - config - hooks []Hook - mutation *UsersMutation -} - -// Where appends a list predicates to the UsersDelete builder. -func (ud *UsersDelete) Where(ps ...predicate.Users) *UsersDelete { - ud.mutation.Where(ps...) - return ud -} - -// Exec executes the deletion query and returns how many vertices were deleted. -func (ud *UsersDelete) Exec(ctx context.Context) (int, error) { - var ( - err error - affected int - ) - if len(ud.hooks) == 0 { - affected, err = ud.sqlExec(ctx) - } else { - var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { - mutation, ok := m.(*UsersMutation) - if !ok { - return nil, fmt.Errorf("unexpected mutation type %T", m) - } - ud.mutation = mutation - affected, err = ud.sqlExec(ctx) - mutation.done = true - return affected, err - }) - for i := len(ud.hooks) - 1; i >= 0; i-- { - if ud.hooks[i] == nil { - return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)") - } - mut = ud.hooks[i](mut) - } - if _, err := mut.Mutate(ctx, ud.mutation); err != nil { - return 0, err - } - } - return affected, err -} - -// ExecX is like Exec, but panics if an error occurs. -func (ud *UsersDelete) ExecX(ctx context.Context) int { - n, err := ud.Exec(ctx) - if err != nil { - panic(err) - } - return n -} - -func (ud *UsersDelete) sqlExec(ctx context.Context) (int, error) { - _spec := &sqlgraph.DeleteSpec{ - Node: &sqlgraph.NodeSpec{ - Table: users.Table, - ID: &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldID, - }, - }, - } - if ps := ud.mutation.predicates; len(ps) > 0 { - _spec.Predicate = func(selector *sql.Selector) { - for i := range ps { - ps[i](selector) - } - } - } - return sqlgraph.DeleteNodes(ctx, ud.driver, _spec) -} - -// UsersDeleteOne is the builder for deleting a single Users entity. -type UsersDeleteOne struct { - ud *UsersDelete -} - -// Exec executes the deletion query. -func (udo *UsersDeleteOne) Exec(ctx context.Context) error { - n, err := udo.ud.Exec(ctx) - switch { - case err != nil: - return err - case n == 0: - return &NotFoundError{users.Label} - default: - return nil - } -} - -// ExecX is like Exec, but panics if an error occurs. -func (udo *UsersDeleteOne) ExecX(ctx context.Context) { - udo.ud.ExecX(ctx) -} diff --git a/ent/users_query.go b/ent/users_query.go deleted file mode 100644 index 720f79e..0000000 --- a/ent/users_query.go +++ /dev/null @@ -1,920 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package ent - -import ( - "context" - "errors" - "fmt" - "math" - "t/ent/predicate" - "t/ent/users" - - "entgo.io/ent/dialect/sql" - "entgo.io/ent/dialect/sql/sqlgraph" - "entgo.io/ent/schema/field" -) - -// UsersQuery is the builder for querying Users entities. -type UsersQuery struct { - config - limit *int - offset *int - unique *bool - order []OrderFunc - fields []string - predicates []predicate.Users - // intermediate query (i.e. traversal path). - sql *sql.Selector - path func(context.Context) (*sql.Selector, error) -} - -// Where adds a new predicate for the UsersQuery builder. -func (uq *UsersQuery) Where(ps ...predicate.Users) *UsersQuery { - uq.predicates = append(uq.predicates, ps...) - return uq -} - -// Limit adds a limit step to the query. -func (uq *UsersQuery) Limit(limit int) *UsersQuery { - uq.limit = &limit - return uq -} - -// Offset adds an offset step to the query. -func (uq *UsersQuery) Offset(offset int) *UsersQuery { - uq.offset = &offset - return uq -} - -// 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 (uq *UsersQuery) Unique(unique bool) *UsersQuery { - uq.unique = &unique - return uq -} - -// Order adds an order step to the query. -func (uq *UsersQuery) Order(o ...OrderFunc) *UsersQuery { - uq.order = append(uq.order, o...) - return uq -} - -// First returns the first Users entity from the query. -// Returns a *NotFoundError when no Users was found. -func (uq *UsersQuery) First(ctx context.Context) (*Users, error) { - nodes, err := uq.Limit(1).All(ctx) - if err != nil { - return nil, err - } - if len(nodes) == 0 { - return nil, &NotFoundError{users.Label} - } - return nodes[0], nil -} - -// FirstX is like First, but panics if an error occurs. -func (uq *UsersQuery) FirstX(ctx context.Context) *Users { - node, err := uq.First(ctx) - if err != nil && !IsNotFound(err) { - panic(err) - } - return node -} - -// FirstID returns the first Users ID from the query. -// Returns a *NotFoundError when no Users ID was found. -func (uq *UsersQuery) FirstID(ctx context.Context) (id int, err error) { - var ids []int - if ids, err = uq.Limit(1).IDs(ctx); err != nil { - return - } - if len(ids) == 0 { - err = &NotFoundError{users.Label} - return - } - return ids[0], nil -} - -// FirstIDX is like FirstID, but panics if an error occurs. -func (uq *UsersQuery) FirstIDX(ctx context.Context) int { - id, err := uq.FirstID(ctx) - if err != nil && !IsNotFound(err) { - panic(err) - } - return id -} - -// Only returns a single Users entity found by the query, ensuring it only returns one. -// Returns a *NotSingularError when exactly one Users entity is not found. -// Returns a *NotFoundError when no Users entities are found. -func (uq *UsersQuery) Only(ctx context.Context) (*Users, error) { - nodes, err := uq.Limit(2).All(ctx) - if err != nil { - return nil, err - } - switch len(nodes) { - case 1: - return nodes[0], nil - case 0: - return nil, &NotFoundError{users.Label} - default: - return nil, &NotSingularError{users.Label} - } -} - -// OnlyX is like Only, but panics if an error occurs. -func (uq *UsersQuery) OnlyX(ctx context.Context) *Users { - node, err := uq.Only(ctx) - if err != nil { - panic(err) - } - return node -} - -// OnlyID is like Only, but returns the only Users ID in the query. -// Returns a *NotSingularError when exactly one Users ID is not found. -// Returns a *NotFoundError when no entities are found. -func (uq *UsersQuery) OnlyID(ctx context.Context) (id int, err error) { - var ids []int - if ids, err = uq.Limit(2).IDs(ctx); err != nil { - return - } - switch len(ids) { - case 1: - id = ids[0] - case 0: - err = &NotFoundError{users.Label} - default: - err = &NotSingularError{users.Label} - } - return -} - -// OnlyIDX is like OnlyID, but panics if an error occurs. -func (uq *UsersQuery) OnlyIDX(ctx context.Context) int { - id, err := uq.OnlyID(ctx) - if err != nil { - panic(err) - } - return id -} - -// All executes the query and returns a list of UsersSlice. -func (uq *UsersQuery) All(ctx context.Context) ([]*Users, error) { - if err := uq.prepareQuery(ctx); err != nil { - return nil, err - } - return uq.sqlAll(ctx) -} - -// AllX is like All, but panics if an error occurs. -func (uq *UsersQuery) AllX(ctx context.Context) []*Users { - nodes, err := uq.All(ctx) - if err != nil { - panic(err) - } - return nodes -} - -// IDs executes the query and returns a list of Users IDs. -func (uq *UsersQuery) IDs(ctx context.Context) ([]int, error) { - var ids []int - if err := uq.Select(users.FieldID).Scan(ctx, &ids); err != nil { - return nil, err - } - return ids, nil -} - -// IDsX is like IDs, but panics if an error occurs. -func (uq *UsersQuery) IDsX(ctx context.Context) []int { - ids, err := uq.IDs(ctx) - if err != nil { - panic(err) - } - return ids -} - -// Count returns the count of the given query. -func (uq *UsersQuery) Count(ctx context.Context) (int, error) { - if err := uq.prepareQuery(ctx); err != nil { - return 0, err - } - return uq.sqlCount(ctx) -} - -// CountX is like Count, but panics if an error occurs. -func (uq *UsersQuery) CountX(ctx context.Context) int { - count, err := uq.Count(ctx) - if err != nil { - panic(err) - } - return count -} - -// Exist returns true if the query has elements in the graph. -func (uq *UsersQuery) Exist(ctx context.Context) (bool, error) { - if err := uq.prepareQuery(ctx); err != nil { - return false, err - } - return uq.sqlExist(ctx) -} - -// ExistX is like Exist, but panics if an error occurs. -func (uq *UsersQuery) ExistX(ctx context.Context) bool { - exist, err := uq.Exist(ctx) - if err != nil { - panic(err) - } - return exist -} - -// Clone returns a duplicate of the UsersQuery builder, including all associated steps. It can be -// used to prepare common query builders and use them differently after the clone is made. -func (uq *UsersQuery) Clone() *UsersQuery { - if uq == nil { - return nil - } - return &UsersQuery{ - config: uq.config, - limit: uq.limit, - offset: uq.offset, - order: append([]OrderFunc{}, uq.order...), - predicates: append([]predicate.Users{}, uq.predicates...), - // clone intermediate query. - sql: uq.sql.Clone(), - path: uq.path, - } -} - -// GroupBy is used to group vertices by one or more fields/columns. -// It is often used with aggregate functions, like: count, max, mean, min, sum. -// -// Example: -// -// var v []struct { -// User string `json:"user,omitempty"` -// Count int `json:"count,omitempty"` -// } -// -// client.Users.Query(). -// GroupBy(users.FieldUser). -// Aggregate(ent.Count()). -// Scan(ctx, &v) -// -func (uq *UsersQuery) GroupBy(field string, fields ...string) *UsersGroupBy { - group := &UsersGroupBy{config: uq.config} - group.fields = append([]string{field}, fields...) - group.path = func(ctx context.Context) (prev *sql.Selector, err error) { - if err := uq.prepareQuery(ctx); err != nil { - return nil, err - } - return uq.sqlQuery(ctx), nil - } - return group -} - -// 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 { -// User string `json:"user,omitempty"` -// } -// -// client.Users.Query(). -// Select(users.FieldUser). -// Scan(ctx, &v) -// -func (uq *UsersQuery) Select(fields ...string) *UsersSelect { - uq.fields = append(uq.fields, fields...) - return &UsersSelect{UsersQuery: uq} -} - -func (uq *UsersQuery) prepareQuery(ctx context.Context) error { - for _, f := range uq.fields { - if !users.ValidColumn(f) { - return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} - } - } - if uq.path != nil { - prev, err := uq.path(ctx) - if err != nil { - return err - } - uq.sql = prev - } - return nil -} - -func (uq *UsersQuery) sqlAll(ctx context.Context) ([]*Users, error) { - var ( - nodes = []*Users{} - _spec = uq.querySpec() - ) - _spec.ScanValues = func(columns []string) ([]interface{}, error) { - node := &Users{config: uq.config} - nodes = append(nodes, node) - return node.scanValues(columns) - } - _spec.Assign = func(columns []string, values []interface{}) error { - if len(nodes) == 0 { - return fmt.Errorf("ent: Assign called without calling ScanValues") - } - node := nodes[len(nodes)-1] - return node.assignValues(columns, values) - } - if err := sqlgraph.QueryNodes(ctx, uq.driver, _spec); err != nil { - return nil, err - } - if len(nodes) == 0 { - return nodes, nil - } - return nodes, nil -} - -func (uq *UsersQuery) sqlCount(ctx context.Context) (int, error) { - _spec := uq.querySpec() - _spec.Node.Columns = uq.fields - if len(uq.fields) > 0 { - _spec.Unique = uq.unique != nil && *uq.unique - } - return sqlgraph.CountNodes(ctx, uq.driver, _spec) -} - -func (uq *UsersQuery) sqlExist(ctx context.Context) (bool, error) { - n, err := uq.sqlCount(ctx) - if err != nil { - return false, fmt.Errorf("ent: check existence: %w", err) - } - return n > 0, nil -} - -func (uq *UsersQuery) querySpec() *sqlgraph.QuerySpec { - _spec := &sqlgraph.QuerySpec{ - Node: &sqlgraph.NodeSpec{ - Table: users.Table, - Columns: users.Columns, - ID: &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldID, - }, - }, - From: uq.sql, - Unique: true, - } - if unique := uq.unique; unique != nil { - _spec.Unique = *unique - } - if fields := uq.fields; len(fields) > 0 { - _spec.Node.Columns = make([]string, 0, len(fields)) - _spec.Node.Columns = append(_spec.Node.Columns, users.FieldID) - for i := range fields { - if fields[i] != users.FieldID { - _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) - } - } - } - if ps := uq.predicates; len(ps) > 0 { - _spec.Predicate = func(selector *sql.Selector) { - for i := range ps { - ps[i](selector) - } - } - } - if limit := uq.limit; limit != nil { - _spec.Limit = *limit - } - if offset := uq.offset; offset != nil { - _spec.Offset = *offset - } - if ps := uq.order; len(ps) > 0 { - _spec.Order = func(selector *sql.Selector) { - for i := range ps { - ps[i](selector) - } - } - } - return _spec -} - -func (uq *UsersQuery) sqlQuery(ctx context.Context) *sql.Selector { - builder := sql.Dialect(uq.driver.Dialect()) - t1 := builder.Table(users.Table) - columns := uq.fields - if len(columns) == 0 { - columns = users.Columns - } - selector := builder.Select(t1.Columns(columns...)...).From(t1) - if uq.sql != nil { - selector = uq.sql - selector.Select(selector.Columns(columns...)...) - } - if uq.unique != nil && *uq.unique { - selector.Distinct() - } - for _, p := range uq.predicates { - p(selector) - } - for _, p := range uq.order { - p(selector) - } - if offset := uq.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 := uq.limit; limit != nil { - selector.Limit(*limit) - } - return selector -} - -// UsersGroupBy is the group-by builder for Users entities. -type UsersGroupBy struct { - config - fields []string - fns []AggregateFunc - // intermediate query (i.e. traversal path). - sql *sql.Selector - path func(context.Context) (*sql.Selector, error) -} - -// Aggregate adds the given aggregation functions to the group-by query. -func (ugb *UsersGroupBy) Aggregate(fns ...AggregateFunc) *UsersGroupBy { - ugb.fns = append(ugb.fns, fns...) - return ugb -} - -// Scan applies the group-by query and scans the result into the given value. -func (ugb *UsersGroupBy) Scan(ctx context.Context, v interface{}) error { - query, err := ugb.path(ctx) - if err != nil { - return err - } - ugb.sql = query - return ugb.sqlScan(ctx, v) -} - -// ScanX is like Scan, but panics if an error occurs. -func (ugb *UsersGroupBy) ScanX(ctx context.Context, v interface{}) { - if err := ugb.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from group-by. -// It is only allowed when executing a group-by query with one field. -func (ugb *UsersGroupBy) Strings(ctx context.Context) ([]string, error) { - if len(ugb.fields) > 1 { - return nil, errors.New("ent: UsersGroupBy.Strings is not achievable when grouping more than 1 field") - } - var v []string - if err := ugb.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (ugb *UsersGroupBy) StringsX(ctx context.Context) []string { - v, err := ugb.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a group-by query. -// It is only allowed when executing a group-by query with one field. -func (ugb *UsersGroupBy) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = ugb.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{users.Label} - default: - err = fmt.Errorf("ent: UsersGroupBy.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (ugb *UsersGroupBy) StringX(ctx context.Context) string { - v, err := ugb.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from group-by. -// It is only allowed when executing a group-by query with one field. -func (ugb *UsersGroupBy) Ints(ctx context.Context) ([]int, error) { - if len(ugb.fields) > 1 { - return nil, errors.New("ent: UsersGroupBy.Ints is not achievable when grouping more than 1 field") - } - var v []int - if err := ugb.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (ugb *UsersGroupBy) IntsX(ctx context.Context) []int { - v, err := ugb.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a group-by query. -// It is only allowed when executing a group-by query with one field. -func (ugb *UsersGroupBy) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = ugb.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{users.Label} - default: - err = fmt.Errorf("ent: UsersGroupBy.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (ugb *UsersGroupBy) IntX(ctx context.Context) int { - v, err := ugb.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from group-by. -// It is only allowed when executing a group-by query with one field. -func (ugb *UsersGroupBy) Float64s(ctx context.Context) ([]float64, error) { - if len(ugb.fields) > 1 { - return nil, errors.New("ent: UsersGroupBy.Float64s is not achievable when grouping more than 1 field") - } - var v []float64 - if err := ugb.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (ugb *UsersGroupBy) Float64sX(ctx context.Context) []float64 { - v, err := ugb.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a group-by query. -// It is only allowed when executing a group-by query with one field. -func (ugb *UsersGroupBy) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = ugb.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{users.Label} - default: - err = fmt.Errorf("ent: UsersGroupBy.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (ugb *UsersGroupBy) Float64X(ctx context.Context) float64 { - v, err := ugb.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from group-by. -// It is only allowed when executing a group-by query with one field. -func (ugb *UsersGroupBy) Bools(ctx context.Context) ([]bool, error) { - if len(ugb.fields) > 1 { - return nil, errors.New("ent: UsersGroupBy.Bools is not achievable when grouping more than 1 field") - } - var v []bool - if err := ugb.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (ugb *UsersGroupBy) BoolsX(ctx context.Context) []bool { - v, err := ugb.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a group-by query. -// It is only allowed when executing a group-by query with one field. -func (ugb *UsersGroupBy) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = ugb.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{users.Label} - default: - err = fmt.Errorf("ent: UsersGroupBy.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (ugb *UsersGroupBy) BoolX(ctx context.Context) bool { - v, err := ugb.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - -func (ugb *UsersGroupBy) sqlScan(ctx context.Context, v interface{}) error { - for _, f := range ugb.fields { - if !users.ValidColumn(f) { - return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)} - } - } - selector := ugb.sqlQuery() - if err := selector.Err(); err != nil { - return err - } - rows := &sql.Rows{} - query, args := selector.Query() - if err := ugb.driver.Query(ctx, query, args, rows); err != nil { - return err - } - defer rows.Close() - return sql.ScanSlice(rows, v) -} - -func (ugb *UsersGroupBy) sqlQuery() *sql.Selector { - selector := ugb.sql.Select() - aggregation := make([]string, 0, len(ugb.fns)) - for _, fn := range ugb.fns { - aggregation = append(aggregation, fn(selector)) - } - // If no columns were selected in a custom aggregation function, the default - // selection is the fields used for "group-by", and the aggregation functions. - if len(selector.SelectedColumns()) == 0 { - columns := make([]string, 0, len(ugb.fields)+len(ugb.fns)) - for _, f := range ugb.fields { - columns = append(columns, selector.C(f)) - } - columns = append(columns, aggregation...) - selector.Select(columns...) - } - return selector.GroupBy(selector.Columns(ugb.fields...)...) -} - -// UsersSelect is the builder for selecting fields of Users entities. -type UsersSelect struct { - *UsersQuery - // intermediate query (i.e. traversal path). - sql *sql.Selector -} - -// Scan applies the selector query and scans the result into the given value. -func (us *UsersSelect) Scan(ctx context.Context, v interface{}) error { - if err := us.prepareQuery(ctx); err != nil { - return err - } - us.sql = us.UsersQuery.sqlQuery(ctx) - return us.sqlScan(ctx, v) -} - -// ScanX is like Scan, but panics if an error occurs. -func (us *UsersSelect) ScanX(ctx context.Context, v interface{}) { - if err := us.Scan(ctx, v); err != nil { - panic(err) - } -} - -// Strings returns list of strings from a selector. It is only allowed when selecting one field. -func (us *UsersSelect) Strings(ctx context.Context) ([]string, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UsersSelect.Strings is not achievable when selecting more than 1 field") - } - var v []string - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// StringsX is like Strings, but panics if an error occurs. -func (us *UsersSelect) StringsX(ctx context.Context) []string { - v, err := us.Strings(ctx) - if err != nil { - panic(err) - } - return v -} - -// String returns a single string from a selector. It is only allowed when selecting one field. -func (us *UsersSelect) String(ctx context.Context) (_ string, err error) { - var v []string - if v, err = us.Strings(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{users.Label} - default: - err = fmt.Errorf("ent: UsersSelect.Strings returned %d results when one was expected", len(v)) - } - return -} - -// StringX is like String, but panics if an error occurs. -func (us *UsersSelect) StringX(ctx context.Context) string { - v, err := us.String(ctx) - if err != nil { - panic(err) - } - return v -} - -// Ints returns list of ints from a selector. It is only allowed when selecting one field. -func (us *UsersSelect) Ints(ctx context.Context) ([]int, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UsersSelect.Ints is not achievable when selecting more than 1 field") - } - var v []int - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// IntsX is like Ints, but panics if an error occurs. -func (us *UsersSelect) IntsX(ctx context.Context) []int { - v, err := us.Ints(ctx) - if err != nil { - panic(err) - } - return v -} - -// Int returns a single int from a selector. It is only allowed when selecting one field. -func (us *UsersSelect) Int(ctx context.Context) (_ int, err error) { - var v []int - if v, err = us.Ints(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{users.Label} - default: - err = fmt.Errorf("ent: UsersSelect.Ints returned %d results when one was expected", len(v)) - } - return -} - -// IntX is like Int, but panics if an error occurs. -func (us *UsersSelect) IntX(ctx context.Context) int { - v, err := us.Int(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64s returns list of float64s from a selector. It is only allowed when selecting one field. -func (us *UsersSelect) Float64s(ctx context.Context) ([]float64, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UsersSelect.Float64s is not achievable when selecting more than 1 field") - } - var v []float64 - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// Float64sX is like Float64s, but panics if an error occurs. -func (us *UsersSelect) Float64sX(ctx context.Context) []float64 { - v, err := us.Float64s(ctx) - if err != nil { - panic(err) - } - return v -} - -// Float64 returns a single float64 from a selector. It is only allowed when selecting one field. -func (us *UsersSelect) Float64(ctx context.Context) (_ float64, err error) { - var v []float64 - if v, err = us.Float64s(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{users.Label} - default: - err = fmt.Errorf("ent: UsersSelect.Float64s returned %d results when one was expected", len(v)) - } - return -} - -// Float64X is like Float64, but panics if an error occurs. -func (us *UsersSelect) Float64X(ctx context.Context) float64 { - v, err := us.Float64(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bools returns list of bools from a selector. It is only allowed when selecting one field. -func (us *UsersSelect) Bools(ctx context.Context) ([]bool, error) { - if len(us.fields) > 1 { - return nil, errors.New("ent: UsersSelect.Bools is not achievable when selecting more than 1 field") - } - var v []bool - if err := us.Scan(ctx, &v); err != nil { - return nil, err - } - return v, nil -} - -// BoolsX is like Bools, but panics if an error occurs. -func (us *UsersSelect) BoolsX(ctx context.Context) []bool { - v, err := us.Bools(ctx) - if err != nil { - panic(err) - } - return v -} - -// Bool returns a single bool from a selector. It is only allowed when selecting one field. -func (us *UsersSelect) Bool(ctx context.Context) (_ bool, err error) { - var v []bool - if v, err = us.Bools(ctx); err != nil { - return - } - switch len(v) { - case 1: - return v[0], nil - case 0: - err = &NotFoundError{users.Label} - default: - err = fmt.Errorf("ent: UsersSelect.Bools returned %d results when one was expected", len(v)) - } - return -} - -// BoolX is like Bool, but panics if an error occurs. -func (us *UsersSelect) BoolX(ctx context.Context) bool { - v, err := us.Bool(ctx) - if err != nil { - panic(err) - } - return v -} - -func (us *UsersSelect) sqlScan(ctx context.Context, v interface{}) error { - rows := &sql.Rows{} - query, args := us.sql.Query() - if err := us.driver.Query(ctx, query, args, rows); err != nil { - return err - } - defer rows.Close() - return sql.ScanSlice(rows, v) -} diff --git a/ent/users_update.go b/ent/users_update.go deleted file mode 100644 index b84f75a..0000000 --- a/ent/users_update.go +++ /dev/null @@ -1,1316 +0,0 @@ -// Code generated by entc, DO NOT EDIT. - -package ent - -import ( - "context" - "errors" - "fmt" - "t/ent/predicate" - "t/ent/users" - "time" - - "entgo.io/ent/dialect/sql" - "entgo.io/ent/dialect/sql/sqlgraph" - "entgo.io/ent/schema/field" -) - -// UsersUpdate is the builder for updating Users entities. -type UsersUpdate struct { - config - hooks []Hook - mutation *UsersMutation -} - -// Where appends a list predicates to the UsersUpdate builder. -func (uu *UsersUpdate) Where(ps ...predicate.Users) *UsersUpdate { - uu.mutation.Where(ps...) - return uu -} - -// SetHp sets the "hp" field. -func (uu *UsersUpdate) SetHp(i int) *UsersUpdate { - uu.mutation.ResetHp() - uu.mutation.SetHp(i) - return uu -} - -// SetNillableHp sets the "hp" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableHp(i *int) *UsersUpdate { - if i != nil { - uu.SetHp(*i) - } - return uu -} - -// AddHp adds i to the "hp" field. -func (uu *UsersUpdate) AddHp(i int) *UsersUpdate { - uu.mutation.AddHp(i) - return uu -} - -// ClearHp clears the value of the "hp" field. -func (uu *UsersUpdate) ClearHp() *UsersUpdate { - uu.mutation.ClearHp() - return uu -} - -// SetAttack sets the "attack" field. -func (uu *UsersUpdate) SetAttack(i int) *UsersUpdate { - uu.mutation.ResetAttack() - uu.mutation.SetAttack(i) - return uu -} - -// SetNillableAttack sets the "attack" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableAttack(i *int) *UsersUpdate { - if i != nil { - uu.SetAttack(*i) - } - return uu -} - -// AddAttack adds i to the "attack" field. -func (uu *UsersUpdate) AddAttack(i int) *UsersUpdate { - uu.mutation.AddAttack(i) - return uu -} - -// ClearAttack clears the value of the "attack" field. -func (uu *UsersUpdate) ClearAttack() *UsersUpdate { - uu.mutation.ClearAttack() - return uu -} - -// SetDefense sets the "defense" field. -func (uu *UsersUpdate) SetDefense(i int) *UsersUpdate { - uu.mutation.ResetDefense() - uu.mutation.SetDefense(i) - return uu -} - -// SetNillableDefense sets the "defense" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableDefense(i *int) *UsersUpdate { - if i != nil { - uu.SetDefense(*i) - } - return uu -} - -// AddDefense adds i to the "defense" field. -func (uu *UsersUpdate) AddDefense(i int) *UsersUpdate { - uu.mutation.AddDefense(i) - return uu -} - -// ClearDefense clears the value of the "defense" field. -func (uu *UsersUpdate) ClearDefense() *UsersUpdate { - uu.mutation.ClearDefense() - return uu -} - -// SetCritical sets the "critical" field. -func (uu *UsersUpdate) SetCritical(i int) *UsersUpdate { - uu.mutation.ResetCritical() - uu.mutation.SetCritical(i) - return uu -} - -// SetNillableCritical sets the "critical" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableCritical(i *int) *UsersUpdate { - if i != nil { - uu.SetCritical(*i) - } - return uu -} - -// AddCritical adds i to the "critical" field. -func (uu *UsersUpdate) AddCritical(i int) *UsersUpdate { - uu.mutation.AddCritical(i) - return uu -} - -// ClearCritical clears the value of the "critical" field. -func (uu *UsersUpdate) ClearCritical() *UsersUpdate { - uu.mutation.ClearCritical() - return uu -} - -// SetBattle sets the "battle" field. -func (uu *UsersUpdate) SetBattle(i int) *UsersUpdate { - uu.mutation.ResetBattle() - uu.mutation.SetBattle(i) - return uu -} - -// SetNillableBattle sets the "battle" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableBattle(i *int) *UsersUpdate { - if i != nil { - uu.SetBattle(*i) - } - return uu -} - -// AddBattle adds i to the "battle" field. -func (uu *UsersUpdate) AddBattle(i int) *UsersUpdate { - uu.mutation.AddBattle(i) - return uu -} - -// ClearBattle clears the value of the "battle" field. -func (uu *UsersUpdate) ClearBattle() *UsersUpdate { - uu.mutation.ClearBattle() - return uu -} - -// SetWin sets the "win" field. -func (uu *UsersUpdate) SetWin(i int) *UsersUpdate { - uu.mutation.ResetWin() - uu.mutation.SetWin(i) - return uu -} - -// SetNillableWin sets the "win" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableWin(i *int) *UsersUpdate { - if i != nil { - uu.SetWin(*i) - } - return uu -} - -// AddWin adds i to the "win" field. -func (uu *UsersUpdate) AddWin(i int) *UsersUpdate { - uu.mutation.AddWin(i) - return uu -} - -// ClearWin clears the value of the "win" field. -func (uu *UsersUpdate) ClearWin() *UsersUpdate { - uu.mutation.ClearWin() - return uu -} - -// SetDay sets the "day" field. -func (uu *UsersUpdate) SetDay(i int) *UsersUpdate { - uu.mutation.ResetDay() - uu.mutation.SetDay(i) - return uu -} - -// SetNillableDay sets the "day" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableDay(i *int) *UsersUpdate { - if i != nil { - uu.SetDay(*i) - } - return uu -} - -// AddDay adds i to the "day" field. -func (uu *UsersUpdate) AddDay(i int) *UsersUpdate { - uu.mutation.AddDay(i) - return uu -} - -// ClearDay clears the value of the "day" field. -func (uu *UsersUpdate) ClearDay() *UsersUpdate { - uu.mutation.ClearDay() - return uu -} - -// SetPercentage sets the "percentage" field. -func (uu *UsersUpdate) SetPercentage(f float64) *UsersUpdate { - uu.mutation.ResetPercentage() - uu.mutation.SetPercentage(f) - return uu -} - -// SetNillablePercentage sets the "percentage" field if the given value is not nil. -func (uu *UsersUpdate) SetNillablePercentage(f *float64) *UsersUpdate { - if f != nil { - uu.SetPercentage(*f) - } - return uu -} - -// AddPercentage adds f to the "percentage" field. -func (uu *UsersUpdate) AddPercentage(f float64) *UsersUpdate { - uu.mutation.AddPercentage(f) - return uu -} - -// ClearPercentage clears the value of the "percentage" field. -func (uu *UsersUpdate) ClearPercentage() *UsersUpdate { - uu.mutation.ClearPercentage() - return uu -} - -// SetLimit sets the "limit" field. -func (uu *UsersUpdate) SetLimit(b bool) *UsersUpdate { - uu.mutation.SetLimit(b) - return uu -} - -// SetNillableLimit sets the "limit" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableLimit(b *bool) *UsersUpdate { - if b != nil { - uu.SetLimit(*b) - } - return uu -} - -// ClearLimit clears the value of the "limit" field. -func (uu *UsersUpdate) ClearLimit() *UsersUpdate { - uu.mutation.ClearLimit() - return uu -} - -// SetComment sets the "comment" field. -func (uu *UsersUpdate) SetComment(s string) *UsersUpdate { - uu.mutation.SetComment(s) - return uu -} - -// SetNillableComment sets the "comment" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableComment(s *string) *UsersUpdate { - if s != nil { - uu.SetComment(*s) - } - return uu -} - -// ClearComment clears the value of the "comment" field. -func (uu *UsersUpdate) ClearComment() *UsersUpdate { - uu.mutation.ClearComment() - return uu -} - -// SetNext sets the "next" field. -func (uu *UsersUpdate) SetNext(s string) *UsersUpdate { - uu.mutation.SetNext(s) - return uu -} - -// SetNillableNext sets the "next" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableNext(s *string) *UsersUpdate { - if s != nil { - uu.SetNext(*s) - } - return uu -} - -// ClearNext clears the value of the "next" field. -func (uu *UsersUpdate) ClearNext() *UsersUpdate { - uu.mutation.ClearNext() - return uu -} - -// SetUpdatedAt sets the "updated_at" field. -func (uu *UsersUpdate) SetUpdatedAt(t time.Time) *UsersUpdate { - uu.mutation.SetUpdatedAt(t) - return uu -} - -// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. -func (uu *UsersUpdate) SetNillableUpdatedAt(t *time.Time) *UsersUpdate { - if t != nil { - uu.SetUpdatedAt(*t) - } - return uu -} - -// ClearUpdatedAt clears the value of the "updated_at" field. -func (uu *UsersUpdate) ClearUpdatedAt() *UsersUpdate { - uu.mutation.ClearUpdatedAt() - return uu -} - -// Mutation returns the UsersMutation object of the builder. -func (uu *UsersUpdate) Mutation() *UsersMutation { - return uu.mutation -} - -// Save executes the query and returns the number of nodes affected by the update operation. -func (uu *UsersUpdate) Save(ctx context.Context) (int, error) { - var ( - err error - affected int - ) - if len(uu.hooks) == 0 { - affected, err = uu.sqlSave(ctx) - } else { - var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { - mutation, ok := m.(*UsersMutation) - if !ok { - return nil, fmt.Errorf("unexpected mutation type %T", m) - } - uu.mutation = mutation - affected, err = uu.sqlSave(ctx) - mutation.done = true - return affected, err - }) - for i := len(uu.hooks) - 1; i >= 0; i-- { - if uu.hooks[i] == nil { - return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)") - } - mut = uu.hooks[i](mut) - } - if _, err := mut.Mutate(ctx, uu.mutation); err != nil { - return 0, err - } - } - return affected, err -} - -// SaveX is like Save, but panics if an error occurs. -func (uu *UsersUpdate) SaveX(ctx context.Context) int { - affected, err := uu.Save(ctx) - if err != nil { - panic(err) - } - return affected -} - -// Exec executes the query. -func (uu *UsersUpdate) Exec(ctx context.Context) error { - _, err := uu.Save(ctx) - return err -} - -// ExecX is like Exec, but panics if an error occurs. -func (uu *UsersUpdate) ExecX(ctx context.Context) { - if err := uu.Exec(ctx); err != nil { - panic(err) - } -} - -func (uu *UsersUpdate) sqlSave(ctx context.Context) (n int, err error) { - _spec := &sqlgraph.UpdateSpec{ - Node: &sqlgraph.NodeSpec{ - Table: users.Table, - Columns: users.Columns, - ID: &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldID, - }, - }, - } - if ps := uu.mutation.predicates; len(ps) > 0 { - _spec.Predicate = func(selector *sql.Selector) { - for i := range ps { - ps[i](selector) - } - } - } - if uu.mutation.CharaCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Column: users.FieldChara, - }) - } - if uu.mutation.SkillCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldSkill, - }) - } - if value, ok := uu.mutation.Hp(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldHp, - }) - } - if value, ok := uu.mutation.AddedHp(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldHp, - }) - } - if uu.mutation.HpCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldHp, - }) - } - if value, ok := uu.mutation.Attack(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldAttack, - }) - } - if value, ok := uu.mutation.AddedAttack(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldAttack, - }) - } - if uu.mutation.AttackCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldAttack, - }) - } - if value, ok := uu.mutation.Defense(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldDefense, - }) - } - if value, ok := uu.mutation.AddedDefense(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldDefense, - }) - } - if uu.mutation.DefenseCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldDefense, - }) - } - if value, ok := uu.mutation.Critical(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldCritical, - }) - } - if value, ok := uu.mutation.AddedCritical(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldCritical, - }) - } - if uu.mutation.CriticalCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldCritical, - }) - } - if value, ok := uu.mutation.Battle(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldBattle, - }) - } - if value, ok := uu.mutation.AddedBattle(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldBattle, - }) - } - if uu.mutation.BattleCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldBattle, - }) - } - if value, ok := uu.mutation.Win(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldWin, - }) - } - if value, ok := uu.mutation.AddedWin(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldWin, - }) - } - if uu.mutation.WinCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldWin, - }) - } - if value, ok := uu.mutation.Day(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldDay, - }) - } - if value, ok := uu.mutation.AddedDay(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldDay, - }) - } - if uu.mutation.DayCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldDay, - }) - } - if value, ok := uu.mutation.Percentage(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeFloat64, - Value: value, - Column: users.FieldPercentage, - }) - } - if value, ok := uu.mutation.AddedPercentage(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeFloat64, - Value: value, - Column: users.FieldPercentage, - }) - } - if uu.mutation.PercentageCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeFloat64, - Column: users.FieldPercentage, - }) - } - if value, ok := uu.mutation.Limit(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeBool, - Value: value, - Column: users.FieldLimit, - }) - } - if uu.mutation.LimitCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeBool, - Column: users.FieldLimit, - }) - } - if uu.mutation.StatusCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Column: users.FieldStatus, - }) - } - if value, ok := uu.mutation.Comment(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Value: value, - Column: users.FieldComment, - }) - } - if uu.mutation.CommentCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Column: users.FieldComment, - }) - } - if uu.mutation.CreatedAtCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeTime, - Column: users.FieldCreatedAt, - }) - } - if value, ok := uu.mutation.Next(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Value: value, - Column: users.FieldNext, - }) - } - if uu.mutation.NextCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Column: users.FieldNext, - }) - } - if value, ok := uu.mutation.UpdatedAt(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeTime, - Value: value, - Column: users.FieldUpdatedAt, - }) - } - if uu.mutation.UpdatedAtCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeTime, - Column: users.FieldUpdatedAt, - }) - } - if uu.mutation.URLCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Column: users.FieldURL, - }) - } - if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, _spec); err != nil { - if _, ok := err.(*sqlgraph.NotFoundError); ok { - err = &NotFoundError{users.Label} - } else if sqlgraph.IsConstraintError(err) { - err = &ConstraintError{err.Error(), err} - } - return 0, err - } - return n, nil -} - -// UsersUpdateOne is the builder for updating a single Users entity. -type UsersUpdateOne struct { - config - fields []string - hooks []Hook - mutation *UsersMutation -} - -// SetHp sets the "hp" field. -func (uuo *UsersUpdateOne) SetHp(i int) *UsersUpdateOne { - uuo.mutation.ResetHp() - uuo.mutation.SetHp(i) - return uuo -} - -// SetNillableHp sets the "hp" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableHp(i *int) *UsersUpdateOne { - if i != nil { - uuo.SetHp(*i) - } - return uuo -} - -// AddHp adds i to the "hp" field. -func (uuo *UsersUpdateOne) AddHp(i int) *UsersUpdateOne { - uuo.mutation.AddHp(i) - return uuo -} - -// ClearHp clears the value of the "hp" field. -func (uuo *UsersUpdateOne) ClearHp() *UsersUpdateOne { - uuo.mutation.ClearHp() - return uuo -} - -// SetAttack sets the "attack" field. -func (uuo *UsersUpdateOne) SetAttack(i int) *UsersUpdateOne { - uuo.mutation.ResetAttack() - uuo.mutation.SetAttack(i) - return uuo -} - -// SetNillableAttack sets the "attack" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableAttack(i *int) *UsersUpdateOne { - if i != nil { - uuo.SetAttack(*i) - } - return uuo -} - -// AddAttack adds i to the "attack" field. -func (uuo *UsersUpdateOne) AddAttack(i int) *UsersUpdateOne { - uuo.mutation.AddAttack(i) - return uuo -} - -// ClearAttack clears the value of the "attack" field. -func (uuo *UsersUpdateOne) ClearAttack() *UsersUpdateOne { - uuo.mutation.ClearAttack() - return uuo -} - -// SetDefense sets the "defense" field. -func (uuo *UsersUpdateOne) SetDefense(i int) *UsersUpdateOne { - uuo.mutation.ResetDefense() - uuo.mutation.SetDefense(i) - return uuo -} - -// SetNillableDefense sets the "defense" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableDefense(i *int) *UsersUpdateOne { - if i != nil { - uuo.SetDefense(*i) - } - return uuo -} - -// AddDefense adds i to the "defense" field. -func (uuo *UsersUpdateOne) AddDefense(i int) *UsersUpdateOne { - uuo.mutation.AddDefense(i) - return uuo -} - -// ClearDefense clears the value of the "defense" field. -func (uuo *UsersUpdateOne) ClearDefense() *UsersUpdateOne { - uuo.mutation.ClearDefense() - return uuo -} - -// SetCritical sets the "critical" field. -func (uuo *UsersUpdateOne) SetCritical(i int) *UsersUpdateOne { - uuo.mutation.ResetCritical() - uuo.mutation.SetCritical(i) - return uuo -} - -// SetNillableCritical sets the "critical" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableCritical(i *int) *UsersUpdateOne { - if i != nil { - uuo.SetCritical(*i) - } - return uuo -} - -// AddCritical adds i to the "critical" field. -func (uuo *UsersUpdateOne) AddCritical(i int) *UsersUpdateOne { - uuo.mutation.AddCritical(i) - return uuo -} - -// ClearCritical clears the value of the "critical" field. -func (uuo *UsersUpdateOne) ClearCritical() *UsersUpdateOne { - uuo.mutation.ClearCritical() - return uuo -} - -// SetBattle sets the "battle" field. -func (uuo *UsersUpdateOne) SetBattle(i int) *UsersUpdateOne { - uuo.mutation.ResetBattle() - uuo.mutation.SetBattle(i) - return uuo -} - -// SetNillableBattle sets the "battle" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableBattle(i *int) *UsersUpdateOne { - if i != nil { - uuo.SetBattle(*i) - } - return uuo -} - -// AddBattle adds i to the "battle" field. -func (uuo *UsersUpdateOne) AddBattle(i int) *UsersUpdateOne { - uuo.mutation.AddBattle(i) - return uuo -} - -// ClearBattle clears the value of the "battle" field. -func (uuo *UsersUpdateOne) ClearBattle() *UsersUpdateOne { - uuo.mutation.ClearBattle() - return uuo -} - -// SetWin sets the "win" field. -func (uuo *UsersUpdateOne) SetWin(i int) *UsersUpdateOne { - uuo.mutation.ResetWin() - uuo.mutation.SetWin(i) - return uuo -} - -// SetNillableWin sets the "win" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableWin(i *int) *UsersUpdateOne { - if i != nil { - uuo.SetWin(*i) - } - return uuo -} - -// AddWin adds i to the "win" field. -func (uuo *UsersUpdateOne) AddWin(i int) *UsersUpdateOne { - uuo.mutation.AddWin(i) - return uuo -} - -// ClearWin clears the value of the "win" field. -func (uuo *UsersUpdateOne) ClearWin() *UsersUpdateOne { - uuo.mutation.ClearWin() - return uuo -} - -// SetDay sets the "day" field. -func (uuo *UsersUpdateOne) SetDay(i int) *UsersUpdateOne { - uuo.mutation.ResetDay() - uuo.mutation.SetDay(i) - return uuo -} - -// SetNillableDay sets the "day" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableDay(i *int) *UsersUpdateOne { - if i != nil { - uuo.SetDay(*i) - } - return uuo -} - -// AddDay adds i to the "day" field. -func (uuo *UsersUpdateOne) AddDay(i int) *UsersUpdateOne { - uuo.mutation.AddDay(i) - return uuo -} - -// ClearDay clears the value of the "day" field. -func (uuo *UsersUpdateOne) ClearDay() *UsersUpdateOne { - uuo.mutation.ClearDay() - return uuo -} - -// SetPercentage sets the "percentage" field. -func (uuo *UsersUpdateOne) SetPercentage(f float64) *UsersUpdateOne { - uuo.mutation.ResetPercentage() - uuo.mutation.SetPercentage(f) - return uuo -} - -// SetNillablePercentage sets the "percentage" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillablePercentage(f *float64) *UsersUpdateOne { - if f != nil { - uuo.SetPercentage(*f) - } - return uuo -} - -// AddPercentage adds f to the "percentage" field. -func (uuo *UsersUpdateOne) AddPercentage(f float64) *UsersUpdateOne { - uuo.mutation.AddPercentage(f) - return uuo -} - -// ClearPercentage clears the value of the "percentage" field. -func (uuo *UsersUpdateOne) ClearPercentage() *UsersUpdateOne { - uuo.mutation.ClearPercentage() - return uuo -} - -// SetLimit sets the "limit" field. -func (uuo *UsersUpdateOne) SetLimit(b bool) *UsersUpdateOne { - uuo.mutation.SetLimit(b) - return uuo -} - -// SetNillableLimit sets the "limit" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableLimit(b *bool) *UsersUpdateOne { - if b != nil { - uuo.SetLimit(*b) - } - return uuo -} - -// ClearLimit clears the value of the "limit" field. -func (uuo *UsersUpdateOne) ClearLimit() *UsersUpdateOne { - uuo.mutation.ClearLimit() - return uuo -} - -// SetComment sets the "comment" field. -func (uuo *UsersUpdateOne) SetComment(s string) *UsersUpdateOne { - uuo.mutation.SetComment(s) - return uuo -} - -// SetNillableComment sets the "comment" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableComment(s *string) *UsersUpdateOne { - if s != nil { - uuo.SetComment(*s) - } - return uuo -} - -// ClearComment clears the value of the "comment" field. -func (uuo *UsersUpdateOne) ClearComment() *UsersUpdateOne { - uuo.mutation.ClearComment() - return uuo -} - -// SetNext sets the "next" field. -func (uuo *UsersUpdateOne) SetNext(s string) *UsersUpdateOne { - uuo.mutation.SetNext(s) - return uuo -} - -// SetNillableNext sets the "next" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableNext(s *string) *UsersUpdateOne { - if s != nil { - uuo.SetNext(*s) - } - return uuo -} - -// ClearNext clears the value of the "next" field. -func (uuo *UsersUpdateOne) ClearNext() *UsersUpdateOne { - uuo.mutation.ClearNext() - return uuo -} - -// SetUpdatedAt sets the "updated_at" field. -func (uuo *UsersUpdateOne) SetUpdatedAt(t time.Time) *UsersUpdateOne { - uuo.mutation.SetUpdatedAt(t) - return uuo -} - -// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. -func (uuo *UsersUpdateOne) SetNillableUpdatedAt(t *time.Time) *UsersUpdateOne { - if t != nil { - uuo.SetUpdatedAt(*t) - } - return uuo -} - -// ClearUpdatedAt clears the value of the "updated_at" field. -func (uuo *UsersUpdateOne) ClearUpdatedAt() *UsersUpdateOne { - uuo.mutation.ClearUpdatedAt() - return uuo -} - -// Mutation returns the UsersMutation object of the builder. -func (uuo *UsersUpdateOne) Mutation() *UsersMutation { - return uuo.mutation -} - -// Select allows selecting one or more fields (columns) of the returned entity. -// The default is selecting all fields defined in the entity schema. -func (uuo *UsersUpdateOne) Select(field string, fields ...string) *UsersUpdateOne { - uuo.fields = append([]string{field}, fields...) - return uuo -} - -// Save executes the query and returns the updated Users entity. -func (uuo *UsersUpdateOne) Save(ctx context.Context) (*Users, error) { - var ( - err error - node *Users - ) - if len(uuo.hooks) == 0 { - node, err = uuo.sqlSave(ctx) - } else { - var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { - mutation, ok := m.(*UsersMutation) - if !ok { - return nil, fmt.Errorf("unexpected mutation type %T", m) - } - uuo.mutation = mutation - node, err = uuo.sqlSave(ctx) - mutation.done = true - return node, err - }) - for i := len(uuo.hooks) - 1; i >= 0; i-- { - if uuo.hooks[i] == nil { - return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)") - } - mut = uuo.hooks[i](mut) - } - if _, err := mut.Mutate(ctx, uuo.mutation); err != nil { - return nil, err - } - } - return node, err -} - -// SaveX is like Save, but panics if an error occurs. -func (uuo *UsersUpdateOne) SaveX(ctx context.Context) *Users { - node, err := uuo.Save(ctx) - if err != nil { - panic(err) - } - return node -} - -// Exec executes the query on the entity. -func (uuo *UsersUpdateOne) Exec(ctx context.Context) error { - _, err := uuo.Save(ctx) - return err -} - -// ExecX is like Exec, but panics if an error occurs. -func (uuo *UsersUpdateOne) ExecX(ctx context.Context) { - if err := uuo.Exec(ctx); err != nil { - panic(err) - } -} - -func (uuo *UsersUpdateOne) sqlSave(ctx context.Context) (_node *Users, err error) { - _spec := &sqlgraph.UpdateSpec{ - Node: &sqlgraph.NodeSpec{ - Table: users.Table, - Columns: users.Columns, - ID: &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldID, - }, - }, - } - id, ok := uuo.mutation.ID() - if !ok { - return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Users.id" for update`)} - } - _spec.Node.ID.Value = id - if fields := uuo.fields; len(fields) > 0 { - _spec.Node.Columns = make([]string, 0, len(fields)) - _spec.Node.Columns = append(_spec.Node.Columns, users.FieldID) - for _, f := range fields { - if !users.ValidColumn(f) { - return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} - } - if f != users.FieldID { - _spec.Node.Columns = append(_spec.Node.Columns, f) - } - } - } - if ps := uuo.mutation.predicates; len(ps) > 0 { - _spec.Predicate = func(selector *sql.Selector) { - for i := range ps { - ps[i](selector) - } - } - } - if uuo.mutation.CharaCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Column: users.FieldChara, - }) - } - if uuo.mutation.SkillCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldSkill, - }) - } - if value, ok := uuo.mutation.Hp(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldHp, - }) - } - if value, ok := uuo.mutation.AddedHp(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldHp, - }) - } - if uuo.mutation.HpCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldHp, - }) - } - if value, ok := uuo.mutation.Attack(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldAttack, - }) - } - if value, ok := uuo.mutation.AddedAttack(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldAttack, - }) - } - if uuo.mutation.AttackCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldAttack, - }) - } - if value, ok := uuo.mutation.Defense(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldDefense, - }) - } - if value, ok := uuo.mutation.AddedDefense(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldDefense, - }) - } - if uuo.mutation.DefenseCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldDefense, - }) - } - if value, ok := uuo.mutation.Critical(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldCritical, - }) - } - if value, ok := uuo.mutation.AddedCritical(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldCritical, - }) - } - if uuo.mutation.CriticalCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldCritical, - }) - } - if value, ok := uuo.mutation.Battle(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldBattle, - }) - } - if value, ok := uuo.mutation.AddedBattle(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldBattle, - }) - } - if uuo.mutation.BattleCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldBattle, - }) - } - if value, ok := uuo.mutation.Win(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldWin, - }) - } - if value, ok := uuo.mutation.AddedWin(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldWin, - }) - } - if uuo.mutation.WinCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldWin, - }) - } - if value, ok := uuo.mutation.Day(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldDay, - }) - } - if value, ok := uuo.mutation.AddedDay(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Value: value, - Column: users.FieldDay, - }) - } - if uuo.mutation.DayCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeInt, - Column: users.FieldDay, - }) - } - if value, ok := uuo.mutation.Percentage(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeFloat64, - Value: value, - Column: users.FieldPercentage, - }) - } - if value, ok := uuo.mutation.AddedPercentage(); ok { - _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ - Type: field.TypeFloat64, - Value: value, - Column: users.FieldPercentage, - }) - } - if uuo.mutation.PercentageCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeFloat64, - Column: users.FieldPercentage, - }) - } - if value, ok := uuo.mutation.Limit(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeBool, - Value: value, - Column: users.FieldLimit, - }) - } - if uuo.mutation.LimitCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeBool, - Column: users.FieldLimit, - }) - } - if uuo.mutation.StatusCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Column: users.FieldStatus, - }) - } - if value, ok := uuo.mutation.Comment(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Value: value, - Column: users.FieldComment, - }) - } - if uuo.mutation.CommentCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Column: users.FieldComment, - }) - } - if uuo.mutation.CreatedAtCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeTime, - Column: users.FieldCreatedAt, - }) - } - if value, ok := uuo.mutation.Next(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Value: value, - Column: users.FieldNext, - }) - } - if uuo.mutation.NextCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Column: users.FieldNext, - }) - } - if value, ok := uuo.mutation.UpdatedAt(); ok { - _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ - Type: field.TypeTime, - Value: value, - Column: users.FieldUpdatedAt, - }) - } - if uuo.mutation.UpdatedAtCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeTime, - Column: users.FieldUpdatedAt, - }) - } - if uuo.mutation.URLCleared() { - _spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{ - Type: field.TypeString, - Column: users.FieldURL, - }) - } - _node = &Users{config: uuo.config} - _spec.Assign = _node.assignValues - _spec.ScanValues = _node.scanValues - if err = sqlgraph.UpdateNode(ctx, uuo.driver, _spec); err != nil { - if _, ok := err.(*sqlgraph.NotFoundError); ok { - err = &NotFoundError{users.Label} - } else if sqlgraph.IsConstraintError(err) { - err = &ConstraintError{err.Error(), err} - } - return nil, err - } - return _node, nil -} diff --git a/fly.toml b/fly.toml deleted file mode 100644 index edb1501..0000000 --- a/fly.toml +++ /dev/null @@ -1,29 +0,0 @@ -# fly.toml file generated for ent on 2022-08-31T13:39:30+09:00 - -app = "ent" -kill_signal = "SIGINT" -kill_timeout = 5 - -[build] - builder = "paketobuildpacks/builder:base" - buildpacks = ["gcr.io/paketo-buildpacks/go"] - -[env] - PORT = "8080" - -[processes] - api = "bin/t" - -[[services]] - internal_port = 8080 - processes = ["api"] - protocol = "tcp" - - [[services.ports]] - force_https = true - handlers = ["http"] - port = 80 - - [[services.ports]] - handlers = ["tls", "http"] - port = 443 diff --git a/go.mod b/go.mod index dd6f518..b594e4e 100644 --- a/go.mod +++ b/go.mod @@ -1,59 +1,56 @@ module t -// +heroku goVersion go1.17 -go 1.17 +go 1.19 + +//replace ariga.io/ogent => ../../ require ( - entgo.io/ent v0.10.0 - github.com/go-chi/chi/v5 v5.0.4 - github.com/jackc/pgx/v4 v4.15.0 - github.com/lib/pq v1.10.4 - github.com/mailru/easyjson v0.7.7 - go.uber.org/zap v1.21.0 + entgo.io/ent v0.11.9 + github.com/go-faster/errors v0.6.1 + github.com/go-faster/jx v0.42.0-alpha.1 + github.com/mattn/go-sqlite3 v1.14.16 + github.com/mazen160/go-random v0.0.0-20210308102632-d2b501c85c03 + github.com/ogen-go/ogen v0.59.0 + go.opentelemetry.io/otel v1.13.0 + go.opentelemetry.io/otel/metric v0.36.0 + go.opentelemetry.io/otel/trace v1.13.0 + go.uber.org/multierr v1.9.0 ) require ( - entgo.io/contrib v0.2.1-0.20220210075301-2b75bf138815 // indirect + ariga.io/atlas v0.9.1 // indirect + ariga.io/entviz v0.0.0-20230125130633-6c9be8e08c7c // indirect + ariga.io/ogent v0.0.0-20230309073626-8dc564a6a73e // indirect + entgo.io/contrib v0.3.5 // indirect + github.com/agext/levenshtein v1.2.3 // indirect github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect - github.com/ariga/ogent v0.0.0-20220224071349-f1dbffa2e32a // indirect + github.com/dlclark/regexp2 v1.8.0 // indirect + github.com/fatih/color v1.14.1 // indirect github.com/ghodss/yaml v1.0.0 // indirect - github.com/go-logr/logr v1.2.2 // indirect + github.com/go-faster/yamlx v0.4.1 // indirect + github.com/go-logr/logr v1.2.3 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-openapi/inflect v0.19.0 // indirect github.com/golang/mock v1.6.0 // indirect - github.com/google/go-cmp v0.5.7 // indirect - github.com/jackc/chunkreader/v2 v2.0.1 // indirect - github.com/jackc/pgconn v1.11.0 // indirect - github.com/jackc/pgio v1.0.0 // indirect - github.com/jackc/pgpassfile v1.0.0 // indirect - github.com/jackc/pgproto3/v2 v2.2.0 // indirect - github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b // indirect - github.com/jackc/pgtype v1.10.0 // indirect - github.com/josharian/intern v1.0.0 // indirect + github.com/google/go-cmp v0.5.9 // indirect + github.com/google/uuid v1.3.0 // indirect + github.com/hashicorp/hcl/v2 v2.15.0 // indirect github.com/kyokomi/lottery v1.2.0 // indirect - github.com/segmentio/asm v1.1.3 // indirect - github.com/uniplaces/carbon v0.1.6 // indirect - golang.org/x/crypto v0.0.0-20220112180741-5e0467b6c7ce // indirect - golang.org/x/mod v0.5.1 // indirect - golang.org/x/text v0.3.7 // indirect + github.com/mattn/go-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.17 // indirect + github.com/mitchellh/go-wordwrap v1.0.1 // indirect + github.com/segmentio/asm v1.2.0 // indirect + github.com/sergi/go-diff v1.1.0 // indirect + github.com/stoewer/go-strcase v1.2.0 // indirect + github.com/zclconf/go-cty v1.12.1 // indirect + go.uber.org/atomic v1.10.0 // indirect + go.uber.org/zap v1.24.0 // indirect + golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect + golang.org/x/mod v0.8.0 // indirect + golang.org/x/net v0.7.0 // indirect + golang.org/x/sync v0.1.0 // indirect + golang.org/x/sys v0.5.0 // indirect + golang.org/x/text v0.7.0 // indirect + golang.org/x/tools v0.6.1-0.20230222164832-25d2519c8696 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect ) - -require ( - ariga.io/atlas v0.3.5 // indirect - github.com/agext/levenshtein v1.2.3 // indirect - github.com/go-faster/errors v0.5.0 - github.com/go-faster/jx v0.32.2 - github.com/google/uuid v1.3.0 - github.com/hashicorp/hcl/v2 v2.11.1 // indirect - github.com/mitchellh/go-wordwrap v1.0.1 // indirect - github.com/ogen-go/ogen v0.19.0 - github.com/sergi/go-diff v1.1.0 // indirect - github.com/zclconf/go-cty v1.10.0 // indirect - go.opentelemetry.io/otel v1.4.1 - go.opentelemetry.io/otel/metric v0.27.0 - go.opentelemetry.io/otel/trace v1.4.1 - go.uber.org/atomic v1.9.0 // indirect - go.uber.org/multierr v1.7.0 // indirect - golang.org/x/sys v0.0.0-20220222200937-f2425489ef4c // indirect -) diff --git a/go.sum b/go.sum index c316d9e..7976c00 100644 --- a/go.sum +++ b/go.sum @@ -1,1006 +1,146 @@ -ariga.io/atlas v0.3.2-0.20220120225051-c3fac7d636dd/go.mod h1:XcLUpQX7Cq4qtagEHIleq3MJaBeeJ76BS8doc4gkOJk= -ariga.io/atlas v0.3.5 h1:Os42TUebb14I8DUTM68CBvNMP6l59979IX5cU7IdBOM= -ariga.io/atlas v0.3.5/go.mod h1:XcLUpQX7Cq4qtagEHIleq3MJaBeeJ76BS8doc4gkOJk= -cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= -cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= -cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= -cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= -cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= -cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= -cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= -cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= -cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= -cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= -cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= -cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= -cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= -cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= -cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= -cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= -cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= -cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= -cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= -cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= -cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY= -cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM= -cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY= -cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ= -cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI= -cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4= -cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc= -cloud.google.com/go v0.98.0/go.mod h1:ua6Ush4NALrHk5QXDWnjvZHN93OuF0HfuEPq9I1X0cM= -cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA= -cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= -cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= -cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= -cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= -cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= -cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= -cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= -cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= -cloud.google.com/go/firestore v1.6.1/go.mod h1:asNXNOzBdyVQmEU+ggO8UPodTkEVFW5Qx+rwHnAz+EY= -cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= -cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= -cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= -cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= -cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= -cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= -cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= -cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= -cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= -dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= -entgo.io/contrib v0.2.1-0.20220210075301-2b75bf138815 h1:VBZtzQqTOHvMVHbGHN1L0uJYq7GQFzenL5Xx04tk+ys= -entgo.io/contrib v0.2.1-0.20220210075301-2b75bf138815/go.mod h1:oDXgxZMWGHZAQcuty41ndZahRrGKFmZHiSaV7YDjhvM= -entgo.io/ent v0.10.0 h1:9cBomE1fh+WX34DPYQL7tDNAIvhKa3tXvwxuLyhYCMo= -entgo.io/ent v0.10.0/go.mod h1:5bjIYdTizykmdtPY3knXrrGpxAh0cMjFfxdNnlNiUGU= -github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= -github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +ariga.io/atlas v0.9.1 h1:EpoPMnwsQG0vn9c0sYExpwSYtr7bvuSUXzQclU2pMjc= +ariga.io/atlas v0.9.1/go.mod h1:T230JFcENj4ZZzMkZrXFDSkv+2kXkUgpJ5FQQ5hMcKU= +ariga.io/entviz v0.0.0-20230125130633-6c9be8e08c7c h1:7FbOjKKWKqD7FZXQq3qWcRlvGFO1LGYvVZIWQ2D9Evs= +ariga.io/entviz v0.0.0-20230125130633-6c9be8e08c7c/go.mod h1:wArXZPqbbWBcOmkqwmIF6hIcW+3T1NLDde0iRhW6an8= +ariga.io/ogent v0.0.0-20230309073626-8dc564a6a73e h1:8mxC+4Y7pVKgfoUJIMdChrS95d+TcJ6xuhw49nVYIAY= +ariga.io/ogent v0.0.0-20230309073626-8dc564a6a73e/go.mod h1:95vCbvAYAW6NsWUrSL23k2SQykuf/yjellmwV1X+svI= +entgo.io/contrib v0.3.5 h1:wY85TgRp3j5ix/SZ9IE6Ob5lObHFmVUYH0ZFw1D5Hzc= +entgo.io/contrib v0.3.5/go.mod h1:R5HiFszVD8OVOZKFGRbqYogRxK7z1ruzWyEEesjQwE0= +entgo.io/ent v0.11.9 h1:dbbCkAiPVTRBIJwoZctiSYjB7zxQIBOzVSU5H9VYIQI= +entgo.io/ent v0.11.9/go.mod h1:KWHOcDZn1xk3mz3ipWdKrQpMvwqa/9B69TUuAPP9W6g= github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60= -github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= -github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ= -github.com/Masterminds/semver/v3 v3.1.1 h1:hLg3sBzpNErnxhQtUy/mmLR2I9foDujNK030IGemrRc= -github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs= -github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= -github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558= +github.com/Khan/genqlient v0.5.0 h1:TMZJ+tl/BpbmGyIBiXzKzUftDhw4ZWxQZ+1ydn0gyII= github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo= github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558= -github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= -github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= -github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= -github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= -github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig= -github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= -github.com/apparentlymart/go-dump v0.0.0-20180507223929-23540a00eaa3/go.mod h1:oL81AME2rN47vu18xqj1S1jPIPuN7afo62yKTNn3XMM= -github.com/apparentlymart/go-textseg v1.0.0 h1:rRmlIsPEEhUTIKQb7T++Nz/A5Q6C9IuX2wFoYVvnCs0= -github.com/apparentlymart/go-textseg v1.0.0/go.mod h1:z96Txxhf3xSFMPmb5X/1W05FF/Nj9VFpLOpjS5yuumk= github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6iT90AvPUL1NNfNw= github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo= -github.com/ariga/ogent v0.0.0-20220224071349-f1dbffa2e32a h1:qoEP5z17RvQoqgR2eEfr/rrt1Ej0ZzPRP6t9UFL8Q6c= -github.com/ariga/ogent v0.0.0-20220224071349-f1dbffa2e32a/go.mod h1:rjSPtPmb4XgkC+63icADHqPuaFxGpSY3oQMFg4c8+lc= -github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= -github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= -github.com/armon/go-metrics v0.3.10/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc= -github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= -github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= -github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8= -github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= -github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= -github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= -github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= -github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= -github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= -github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= -github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= -github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= -github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag= -github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I= -github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= -github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= -github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= -github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= -github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= -github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cockroachdb/apd v1.1.0 h1:3LFP3629v+1aKXU5Q37mxmRxX/pIu1nijXydLShEq5I= -github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ= -github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= -github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= -github.com/coreos/go-systemd v0.0.0-20190719114852-fd7a80b32e1f/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= -github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= -github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= -github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/benbjohnson/clock v1.3.0 h1:ip6w0uFQkncKQ979AypyG0ER7mqUSBdKLOgAle/AT8A= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= -github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= -github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= -github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= -github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= -github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= -github.com/envoyproxy/go-control-plane v0.10.1/go.mod h1:AY7fTTXNdv/aJ2O5jwpxAPOWUZ7hQAEvzN5Pf27BkQQ= -github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/envoyproxy/protoc-gen-validate v0.6.2/go.mod h1:2t7qjJNvHPx8IjnBOzl9E9/baC+qXE/TeeyBRzgJDws= -github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= -github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= -github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= -github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU= +github.com/dlclark/regexp2 v1.8.0 h1:rJD5HeGIT/2b5CDk63FVCwZA3qgYElfg+oQK7uH5pfE= +github.com/dlclark/regexp2 v1.8.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/fatih/color v1.14.1 h1:qfhVLaG5s+nCROl1zJsZRxFeYrHLqWroPOQ8BWiNb4w= +github.com/fatih/color v1.14.1/go.mod h1:2oHN61fhTpgcxD3TSWCgKDiH1+x4OiDVVGH8WlgGZGg= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= -github.com/go-chi/chi/v5 v5.0.4 h1:5e494iHzsYBiyXQAHHuI4tyJS9M3V84OuX3ufIIGHFo= -github.com/go-chi/chi/v5 v5.0.4/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8= -github.com/go-faster/errors v0.5.0 h1:hS/zHFJ2Vb14jcupq5J9tk05XW+PFTmySOkDRByHBo4= -github.com/go-faster/errors v0.5.0/go.mod h1:/9SNBcg2ESJTYztBFEiM5Np6ns85BtPNMJd8lFTiFwk= -github.com/go-faster/jx v0.32.1/go.mod h1:T561ezgn74siJgc+QzZzoGHokGBKxV6WZugVyfw+68c= -github.com/go-faster/jx v0.32.2 h1:xrBsEiawju+56UqBpNAjQ3/9ZmiSRzOletSsehRPeRw= -github.com/go-faster/jx v0.32.2/go.mod h1:T561ezgn74siJgc+QzZzoGHokGBKxV6WZugVyfw+68c= -github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= -github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= -github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= -github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= -github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= -github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= -github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= -github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= -github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= -github.com/go-logr/logr v1.2.2 h1:ahHml/yUpnlb96Rp8HCvtYVPY8ZYpxq3g7UYchIYwbs= +github.com/go-faster/errors v0.6.1 h1:nNIPOBkprlKzkThvS/0YaX8Zs9KewLCOSFQS5BU06FI= +github.com/go-faster/errors v0.6.1/go.mod h1:5MGV2/2T9yvlrbhe9pD9LO5Z/2zCSq2T8j+Jpi2LAyY= +github.com/go-faster/jx v0.42.0-alpha.1 h1:KRu+ofEoozOsq2qpjwIp2R08vw9w2VqfbV4wtybQZ9U= +github.com/go-faster/jx v0.42.0-alpha.1/go.mod h1:fTSMeBYBKUmGFJaA6EkF658Rrco40FHenmq9fOBpYuM= +github.com/go-faster/yamlx v0.4.1 h1:00RQkZopoLDF1SgBDJVHuN6epTOK7T0TkN427vbvEBk= +github.com/go-faster/yamlx v0.4.1/go.mod h1:QXr/i3Z00jRhskgyWkoGsEdseebd/ZbZEpGS6DJv8oo= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0= +github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNPXu/4= github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4= -github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= -github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc= github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68= -github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA= -github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= -github.com/gofrs/uuid v4.0.0+incompatible h1:1SD/1F5pU8p29ybwgQSwpQk+mwdRrXCYuPhW6m+TnJw= -github.com/gofrs/uuid v4.0.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= -github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= -github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= -github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= -github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= -github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= -github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= -github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= -github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= -github.com/golang/protobuf v1.1.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= -github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= -github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= -github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= -github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= -github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= -github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= -github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= -github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= -github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= -github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= -github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= -github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM= -github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= -github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= -github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= -github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= -github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= -github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= -github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o= -github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= -github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= -github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= -github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= -github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= -github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= -github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= -github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= -github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= -github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= -github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= -github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM= -github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= -github.com/hashicorp/consul/api v1.11.0/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M= -github.com/hashicorp/consul/sdk v0.8.0/go.mod h1:GBvyrGALthsZObzUGsfgHZQDXjg4lOjagTIwIR1vPms= -github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= -github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= -github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= -github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= -github.com/hashicorp/go-hclog v0.12.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= -github.com/hashicorp/go-hclog v1.0.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= -github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= -github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= -github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM= -github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= -github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA= -github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs= -github.com/hashicorp/go-rootcerts v1.0.2/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8= -github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU= -github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4= -github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= -github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= -github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= -github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= -github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= -github.com/hashicorp/hcl/v2 v2.10.0/go.mod h1:FwWsfWEjyV/CMj8s/gqAuiviY72rJ1/oayI9WftqcKg= -github.com/hashicorp/hcl/v2 v2.11.1 h1:yTyWcXcm9XB0TEkyU/JCRU6rYy4K+mgLtzn2wlrJbcc= -github.com/hashicorp/hcl/v2 v2.11.1/go.mod h1:FwWsfWEjyV/CMj8s/gqAuiviY72rJ1/oayI9WftqcKg= -github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= -github.com/hashicorp/mdns v1.0.1/go.mod h1:4gW7WsVCke5TE7EPeYliwHlRUyBtfCwuFwuMg2DmyNY= -github.com/hashicorp/mdns v1.0.4/go.mod h1:mtBihi+LeNXGtG8L9dX59gAEa12BDtBQSp4v/YAJqrc= -github.com/hashicorp/memberlist v0.2.2/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE= -github.com/hashicorp/memberlist v0.3.0/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE= -github.com/hashicorp/serf v0.9.5/go.mod h1:UWDWwZeL5cuWDJdl0C6wrvrUwEqtQ4ZKBKKENpqIUyk= -github.com/hashicorp/serf v0.9.6/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpTwn9UV4= -github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= -github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= -github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= -github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= -github.com/jackc/chunkreader v1.0.0 h1:4s39bBR8ByfqH+DKm8rQA3E1LHZWB9XWcrz8fqaZbe0= -github.com/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo= -github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk= -github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8= -github.com/jackc/chunkreader/v2 v2.0.1/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk= -github.com/jackc/pgconn v0.0.0-20190420214824-7e0022ef6ba3/go.mod h1:jkELnwuX+w9qN5YIfX0fl88Ehu4XC3keFuOJJk9pcnA= -github.com/jackc/pgconn v0.0.0-20190824142844-760dd75542eb/go.mod h1:lLjNuW/+OfW9/pnVKPazfWOgNfH2aPem8YQ7ilXGvJE= -github.com/jackc/pgconn v0.0.0-20190831204454-2fabfa3c18b7/go.mod h1:ZJKsE/KZfsUgOEh9hBm+xYTstcNHg7UPMVJqRfQxq4s= -github.com/jackc/pgconn v1.8.0/go.mod h1:1C2Pb36bGIP9QHGBYCjnyhqu7Rv3sGshaQUvmfGIB/o= -github.com/jackc/pgconn v1.9.0/go.mod h1:YctiPyvzfU11JFxoXokUOOKQXQmDMoJL9vJzHH8/2JY= -github.com/jackc/pgconn v1.9.1-0.20210724152538-d89c8390a530/go.mod h1:4z2w8XhRbP1hYxkpTuBjTS3ne3J48K83+u0zoyvg2pI= -github.com/jackc/pgconn v1.11.0 h1:HiHArx4yFbwl91X3qqIHtUFoiIfLNJXCQRsnzkiwwaQ= -github.com/jackc/pgconn v1.11.0/go.mod h1:4z2w8XhRbP1hYxkpTuBjTS3ne3J48K83+u0zoyvg2pI= -github.com/jackc/pgio v1.0.0 h1:g12B9UwVnzGhueNavwioyEEpAmqMe1E/BN9ES+8ovkE= -github.com/jackc/pgio v1.0.0/go.mod h1:oP+2QK2wFfUWgr+gxjoBH9KGBb31Eio69xUb0w5bYf8= -github.com/jackc/pgmock v0.0.0-20190831213851-13a1b77aafa2/go.mod h1:fGZlG77KXmcq05nJLRkk0+p82V8B8Dw8KN2/V9c/OAE= -github.com/jackc/pgmock v0.0.0-20201204152224-4fe30f7445fd/go.mod h1:hrBW0Enj2AZTNpt/7Y5rr2xe/9Mn757Wtb2xeBzPv2c= -github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65 h1:DadwsjnMwFjfWc9y5Wi/+Zz7xoE5ALHsRQlOctkOiHc= -github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65/go.mod h1:5R2h2EEX+qri8jOWMbJCtaPWkrrNc7OHwsp2TCqp7ak= -github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= -github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= -github.com/jackc/pgproto3 v1.1.0 h1:FYYE4yRw+AgI8wXIinMlNjBbp/UitDJwfj5LqqewP1A= -github.com/jackc/pgproto3 v1.1.0/go.mod h1:eR5FA3leWg7p9aeAqi37XOTgTIbkABlvcPB3E5rlc78= -github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190420180111-c116219b62db/go.mod h1:bhq50y+xrl9n5mRYyCBFKkpRVTLYJVWeCc+mEAI3yXA= -github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190609003834-432c2951c711/go.mod h1:uH0AWtUmuShn0bcesswc4aBTWGvw0cAxIJp+6OB//Wg= -github.com/jackc/pgproto3/v2 v2.0.0-rc3/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM= -github.com/jackc/pgproto3/v2 v2.0.0-rc3.0.20190831210041-4c03ce451f29/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM= -github.com/jackc/pgproto3/v2 v2.0.6/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA= -github.com/jackc/pgproto3/v2 v2.1.1/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA= -github.com/jackc/pgproto3/v2 v2.2.0 h1:r7JypeP2D3onoQTCxWdTpCtJ4D+qpKr0TxvoyMhZ5ns= -github.com/jackc/pgproto3/v2 v2.2.0/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA= -github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b h1:C8S2+VttkHFdOOCXJe+YGfa4vHYwlt4Zx+IVXQ97jYg= -github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b/go.mod h1:vsD4gTJCa9TptPL8sPkXrLZ+hDuNrZCnj29CQpr4X1E= -github.com/jackc/pgtype v0.0.0-20190421001408-4ed0de4755e0/go.mod h1:hdSHsc1V01CGwFsrv11mJRHWJ6aifDLfdV3aVjFF0zg= -github.com/jackc/pgtype v0.0.0-20190824184912-ab885b375b90/go.mod h1:KcahbBH1nCMSo2DXpzsoWOAfFkdEtEJpPbVLq8eE+mc= -github.com/jackc/pgtype v0.0.0-20190828014616-a8802b16cc59/go.mod h1:MWlu30kVJrUS8lot6TQqcg7mtthZ9T0EoIBFiJcmcyw= -github.com/jackc/pgtype v1.8.1-0.20210724151600-32e20a603178/go.mod h1:C516IlIV9NKqfsMCXTdChteoXmwgUceqaLfjg2e3NlM= -github.com/jackc/pgtype v1.10.0 h1:ILnBWrRMSXGczYvmkYD6PsYyVFUNLTnIUJHHDLmqk38= -github.com/jackc/pgtype v1.10.0/go.mod h1:LUMuVrfsFfdKGLw+AFFVv6KtHOFMwRgDDzBt76IqCA4= -github.com/jackc/pgx/v4 v4.0.0-20190420224344-cc3461e65d96/go.mod h1:mdxmSJJuR08CZQyj1PVQBHy9XOp5p8/SHH6a0psbY9Y= -github.com/jackc/pgx/v4 v4.0.0-20190421002000-1b8f0016e912/go.mod h1:no/Y67Jkk/9WuGR0JG/JseM9irFbnEPbuWV2EELPNuM= -github.com/jackc/pgx/v4 v4.0.0-pre1.0.20190824185557-6972a5742186/go.mod h1:X+GQnOEnf1dqHGpw7JmHqHc1NxDoalibchSk9/RWuDc= -github.com/jackc/pgx/v4 v4.12.1-0.20210724153913-640aa07df17c/go.mod h1:1QD0+tgSXP7iUjYm9C1NxKhny7lq6ee99u/z+IHFcgs= -github.com/jackc/pgx/v4 v4.15.0 h1:B7dTkXsdILD3MF987WGGCcg+tvLW6bZJdEcqVFeU//w= -github.com/jackc/pgx/v4 v4.15.0/go.mod h1:D/zyOyXiaM1TmVWnOM18p0xdDtdakRBa0RsVGI3U3bw= -github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= -github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= -github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= -github.com/jackc/puddle v1.2.1/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= -github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4= -github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= -github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= -github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= -github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= -github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= -github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= -github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= -github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= -github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= -github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= -github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/klauspost/compress v1.14.1/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk= -github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= -github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= +github.com/hashicorp/hcl/v2 v2.15.0 h1:CPDXO6+uORPjKflkWCCwoWc9uRp+zSIPcCQ+BrxV7m8= +github.com/hashicorp/hcl/v2 v2.15.0/go.mod h1:JRmR89jycNkrrqnMmvPDMd56n1rQJ2Q6KocSLCMCXng= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4= -github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k= github.com/kyokomi/lottery v1.2.0 h1:oW9YxYv5j/nu/Kkf8K5tu7Vn8dAoZTjluDxihTPX/68= github.com/kyokomi/lottery v1.2.0/go.mod h1:TkKpJrFrOJNHpblUqYu0bAQWil3NMwKMBluHyqFfU6Y= -github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= -github.com/lib/pq v1.1.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= -github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= -github.com/lib/pq v1.10.2/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= -github.com/lib/pq v1.10.3/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= -github.com/lib/pq v1.10.4 h1:SO9z7FRPzA03QhHKJrH5BXA6HU1rS4V2nIVrrNC1iYk= -github.com/lib/pq v1.10.4/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= -github.com/lyft/protoc-gen-star v0.5.3/go.mod h1:V0xaHgaf5oCCqmcxYcWiDfTiKsZsRc87/1qhoTACD8w= -github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= -github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= -github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= -github.com/manifoldco/promptui v0.9.0/go.mod h1:ka04sppxSGFAtxX0qhlYQjISsg9mR4GWtQEhdbn6Pgg= -github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= -github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ= -github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= -github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= -github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= -github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84= -github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= -github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= -github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= -github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= -github.com/mattn/go-sqlite3 v1.14.10/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= -github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= -github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= -github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso= -github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI= -github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI= -github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= -github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI= -github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo= +github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng= +github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y= +github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= +github.com/mazen160/go-random v0.0.0-20210308102632-d2b501c85c03 h1:iM7JTVzKOYKWjzhGcgHAgFVQt5QfiHIVrRUaWPfh0Q4= +github.com/mazen160/go-random v0.0.0-20210308102632-d2b501c85c03/go.mod h1:APoDd0B2pYeB5kU/g7Mw14mFsljp5HfzrC7arsKbi8U= github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= -github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= -github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= -github.com/mitchellh/mapstructure v1.4.3/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= -github.com/ogen-go/ogen v0.18.1 h1:BtYFZQGSD8PiTztmDjdnguRWNL/Wwy3fUbrsGACjPLQ= -github.com/ogen-go/ogen v0.18.1/go.mod h1:23nkNYuCSapnQw902m9FARM4qSlI0PkGGRddN3V0SS0= -github.com/ogen-go/ogen v0.19.0 h1:rVU3w2WjA9ivlvDwBKtOsIjqRlUPdxEauoL0db3EOjg= -github.com/ogen-go/ogen v0.19.0/go.mod h1:UFCkfw8gvVfhcda6U+CzRzBxPn5BF8MkxEdWsXadCo4= -github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= -github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= -github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= -github.com/pelletier/go-toml v1.9.4/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= -github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/ogen-go/ogen v0.59.0 h1:9aSSZ1KCLJIcRyjkO7IHrG0vAI6l1BO877LwTbMcX+k= +github.com/ogen-go/ogen v0.59.0/go.mod h1:0MHLcWEbxwdvR+R9E05paQSRh/2vHtVSJgKqmwYyW8M= github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= -github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= -github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s= -github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= -github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= -github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU= -github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= -github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= -github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4= -github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= -github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= -github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= -github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= -github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= -github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ= -github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU= -github.com/rs/zerolog v1.15.0/go.mod h1:xYTKnLHcpfU2225ny5qZjxnj9NvkumZYjJHlAThCjNc= -github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= -github.com/sagikazarmark/crypt v0.3.0/go.mod h1:uD/D+6UF4SrIR1uGEv7bBNkNqLGqUr43MRiaGWX1Nig= -github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0= -github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= -github.com/segmentio/asm v1.1.3 h1:WM03sfUOENvvKexOLp+pCqgb/WDjsi7EK8gIsICtzhc= -github.com/segmentio/asm v1.1.3/go.mod h1:Ld3L4ZXGNcSLRg4JBsZ3//1+f/TjYl0Mzen/DQy1EJg= -github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= +github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys= +github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs= github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0= github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM= -github.com/shopspring/decimal v0.0.0-20180709203117-cd690d0c9e24/go.mod h1:M+9NzErvs504Cn4c5DxATwIqPbtswREoFCre64PpcG4= -github.com/shopspring/decimal v1.2.0 h1:abSATXmQEYyShuxI4/vyW3tV1MrKAJzCZ/0zLUXYbsQ= -github.com/shopspring/decimal v1.2.0/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= -github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= -github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= -github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= -github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= -github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= -github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= -github.com/spf13/cast v1.4.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= -github.com/spf13/cobra v1.3.0/go.mod h1:BrRVncBjOJa/eUcVVm9CE+oC6as8k+VYr4NY7WCi9V4= -github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= -github.com/spf13/pflag v1.0.2/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= -github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= -github.com/spf13/viper v1.10.0/go.mod h1:SoyBPwAtKDzypXNDFKN5kzH7ppppbGZtls1UpIy5AsM= github.com/stoewer/go-strcase v1.2.0 h1:Z2iHWqGXH00XYgqDmNgQbIBxf3wrNq0F3feEy0ainaU= +github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= -github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= -github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1-0.20210427113832-6241f9ab9942 h1:t0lM6y/M5IiUZyvbBTcngso8SZEZICH7is9B6g/obVU= -github.com/stretchr/testify v1.7.1-0.20210427113832-6241f9ab9942/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= -github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= -github.com/uniplaces/carbon v0.1.6 h1:JVxwWs8FfwAN+PvB2bh9WCZRX2u1Vp77cGXr51uzxJs= -github.com/uniplaces/carbon v0.1.6/go.mod h1:glebpttsTxh8fBbciRAy3WvLfhBVa8n7qfgDTMAuJ3Y= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasthttp v1.33.0/go.mod h1:KJRK/MXx0J+yd0c5hlR+s1tIHD72sniU8ZJjl97LIw4= -github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc= -github.com/vmihailenco/msgpack v3.3.3+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= -github.com/vmihailenco/msgpack/v4 v4.3.12/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4= -github.com/vmihailenco/tagparser v0.1.1/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI= -github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8= +github.com/vektah/gqlparser/v2 v2.4.5 h1:C02NsyEsL4TXJB7ndonqTfuQOL4XPIu0aAWugdmTgmc= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/zclconf/go-cty v1.2.0/go.mod h1:hOPWgoHbaTUnI5k4D2ld+GRpFJSCe6bCM7m1q/N4PQ8= -github.com/zclconf/go-cty v1.8.0/go.mod h1:vVKLxnk3puL4qRAv72AO+W99LUD4da90g3uUAzyuvAk= -github.com/zclconf/go-cty v1.10.0 h1:mp9ZXQeIcN8kAwuqorjH+Q+njbJKjLrvB2yIh4q7U+0= -github.com/zclconf/go-cty v1.10.0/go.mod h1:vVKLxnk3puL4qRAv72AO+W99LUD4da90g3uUAzyuvAk= -github.com/zclconf/go-cty-debug v0.0.0-20191215020915-b22d67c1ba0b/go.mod h1:ZRKQfBXbGkpdV6QMzT3rU1kSTAnfu1dO8dPKjYprgj8= -github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q= -go.etcd.io/etcd/api/v3 v3.5.1/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= -go.etcd.io/etcd/client/pkg/v3 v3.5.1/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= -go.etcd.io/etcd/client/v2 v2.305.1/go.mod h1:pMEacxZW7o8pg4CrFE7pquyCJJzZvkvdD2RibOCCCGs= -go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= -go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= -go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= -go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= -go.opentelemetry.io/otel v1.4.0/go.mod h1:jeAqMFKy2uLIxCtKxoFj0FAL5zAPKQagc3+GtBWakzk= -go.opentelemetry.io/otel v1.4.1 h1:QbINgGDDcoQUoMJa2mMaWno49lja9sHwp6aoa2n3a4g= -go.opentelemetry.io/otel v1.4.1/go.mod h1:StM6F/0fSwpd8dKWDCdRr7uRvEPYdW0hBSlbdTiUde4= -go.opentelemetry.io/otel/internal/metric v0.27.0 h1:9dAVGAfFiiEq5NVB9FUJ5et+btbDQAUIJehJ+ikyryk= -go.opentelemetry.io/otel/internal/metric v0.27.0/go.mod h1:n1CVxRqKqYZtqyTh9U/onvKapPGv7y/rpyOTI+LFNzw= -go.opentelemetry.io/otel/metric v0.27.0 h1:HhJPsGhJoKRSegPQILFbODU56NS/L1UE4fS1sC5kIwQ= -go.opentelemetry.io/otel/metric v0.27.0/go.mod h1:raXDJ7uP2/Jc0nVZWQjJtzoyssOYWu/+pjZqRzfvZ7g= -go.opentelemetry.io/otel/trace v1.4.0/go.mod h1:uc3eRsqDfWs9R7b92xbQbU42/eTNz4N+gLP8qJCi4aE= -go.opentelemetry.io/otel/trace v1.4.1 h1:O+16qcdTrT7zxv2J6GejTPFinSwA++cYerC5iSiF8EQ= -go.opentelemetry.io/otel/trace v1.4.1/go.mod h1:iYEVbroFCNut9QkwEczV9vMRPHNKSSwYZjulEtsmhFc= -go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= -go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= -go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= -go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= -go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= -go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE= -go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +github.com/zclconf/go-cty v1.12.1 h1:PcupnljUm9EIvbgSHQnHhUr3fO6oFmkOrvs2BAFNXXY= +github.com/zclconf/go-cty v1.12.1/go.mod h1:s9IfD1LK5ccNMSWCVFCE2rJfHiZgi7JijgeWIMfhLvA= +go.opentelemetry.io/otel v1.13.0 h1:1ZAKnNQKwBBxFtww/GwxNUyTf0AxkZzrukO8MeXqe4Y= +go.opentelemetry.io/otel v1.13.0/go.mod h1:FH3RtdZCzRkJYFTCsAKDy9l/XYjMdNv6QrkFFB8DvVg= +go.opentelemetry.io/otel/metric v0.36.0 h1:t0lgGI+L68QWt3QtOIlqM9gXoxqxWLhZ3R/e5oOAY0Q= +go.opentelemetry.io/otel/metric v0.36.0/go.mod h1:wKVw57sd2HdSZAzyfOM9gTqqE8v7CbqWsYL6AyrH9qk= +go.opentelemetry.io/otel/trace v1.13.0 h1:CBgRZ6ntv+Amuj1jDsMhZtlAPT6gbyIRdaIzFhfBSdY= +go.opentelemetry.io/otel/trace v1.13.0/go.mod h1:muCvmmO9KKpvuXSf3KKAXXB2ygNYHQ+ZfI5X08d3tds= +go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ= +go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI= -go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= -go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= -go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= -go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU= -go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= -go.uber.org/multierr v1.7.0 h1:zaiO/rmgFjbmCXdSYJWQcdvOCsthmdaHfr3Gm2Kx4Ec= -go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= -go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= -go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= -go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= -go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= -go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= -go.uber.org/zap v1.21.0 h1:WefMeulhovoZ2sYXz7st6K0sLj7bBhpiFaud4r4zST8= -go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw= -golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= -golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI= +go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ= +go.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60= +go.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20190411191339-88737f569e3a/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE= -golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20201203163018-be400aefbc4c/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= -golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20220112180741-5e0467b6c7ce h1:Roh6XWxHFKrPgC/EQhVubSAGQ6Ozk6IdxHSzt1mR0EI= -golang.org/x/crypto v0.0.0-20220112180741-5e0467b6c7ce/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= -golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= -golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= -golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= -golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= -golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= -golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= -golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= -golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= -golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= -golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= -golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= -golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= -golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= -golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= -golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/exp v0.0.0-20230206171751-46f607a40771 h1:xP7rWLUr1e1n2xkK5YB4LI0hPEy3LJC6Wk+D4pGlOJg= +golang.org/x/exp v0.0.0-20230206171751-46f607a40771/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= -golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38= -golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= -golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20180811021610-c39426892332/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= -golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8= -golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20220111093109-d55c255bac03/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= -golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20211005180243-6b3c2da341f1/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g= +golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190502175342-a43fa875dd82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210303074136-134d130e1a04/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211110154304-99a53858aa08/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211205182925-97ca703d548d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220111092808-5a964db01320/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220222200937-f2425489ef4c h1:sSIdNI2Dd6vGv47bKc/xArpfxVmEz2+3j0E6I484xC4= -golang.org/x/sys v0.0.0-20220222200937-f2425489ef4c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= -golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190425163242-31fd60d6bfdc/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20190823170909-c4a336ef6a2f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= -golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= -golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= -golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= -golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.9-0.20211216111533-8d383106f7e7/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= -golang.org/x/tools v0.1.9 h1:j9KsMiaP1c3B0OTQGth0/k+miLGTgLsAFUCrF2vLcF8= -golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/tools v0.6.1-0.20230222164832-25d2519c8696 h1:8985/C5IvACpd9DDXckSnjSBLKDgbxXiyODgi94zOPM= +golang.org/x/tools v0.6.1-0.20230222164832-25d2519c8696/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= -google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= -google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= -google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= -google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= -google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= -google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= -google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= -google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= -google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= -google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= -google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= -google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= -google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo= -google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4= -google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw= -google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU= -google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k= -google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= -google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= -google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI= -google.golang.org/api v0.59.0/go.mod h1:sT2boj7M9YJxZzgeZqXogmhfmRWDtPzT31xkieUbuZU= -google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I= -google.golang.org/api v0.62.0/go.mod h1:dKmwPCydfsad4qCH08MSdgWjfHOyfpd4VtDGgRFdavw= -google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= -google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= -google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= -google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= -google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= -google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= -google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= -google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= -google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= -google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= -google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= -google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= -google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A= -google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= -google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= -google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= -google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24= -google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= -google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= -google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= -google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= -google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w= -google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211008145708-270636b82663/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211028162531-8db9c33dc351/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211129164237-f09f9a12af12/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211203200212-54befc351ae9/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= -google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= -google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= -google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= -google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= -google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= -google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= -google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= -google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= -google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= -google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= -google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= -google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= -google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= -google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= -google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= -google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= -google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= -google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= -google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= -google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= -google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= -google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= -google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= -google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= -google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= -google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= -google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= -google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= -gopkg.in/inconshreveable/log15.v2 v2.0.0-20180818164646-67afb5ed74ec/go.mod h1:aPpfJ7XW+gOuirDoZ8gHhLh3kZ1B08FtV2bbmy7Jv3s= -gopkg.in/ini.v1 v1.66.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= -honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= -rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= -rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/main.go b/main.go index 948c2a5..9cd8994 100644 --- a/main.go +++ b/main.go @@ -1,146 +1,76 @@ package main import ( -"strconv" - "time" - "t/ent" - "net/http" - "math/rand" "context" "log" - "os" - "database/sql" - entsql "entgo.io/ent/dialect/sql" - "entgo.io/ent/dialect" - _ "github.com/jackc/pgx/v4/stdlib" - _ "github.com/lib/pq" + "net/http" + + "t/ent" "t/ent/ogent" - "entgo.io/ent/dialect/sql/schema" - "github.com/kyokomi/lottery" + "entgo.io/ent/dialect" + _ "github.com/mattn/go-sqlite3" + "time" ) type User struct { - user string `json:"user"` + username string `json:"username"` created_at time.Time `json:"created_at"` } -func Open(databaseUrl string) *ent.Client { - db, err := sql.Open("pgx", databaseUrl) - if err != nil { - log.Fatal(err) - } - drv := entsql.OpenDB(dialect.Postgres, db) - return ent.NewClient(ent.Driver(drv)) -} - -func Random(i int) (l int){ - rand.Seed(time.Now().UnixNano()) - l = rand.Intn(i) - for l == 0 { - l = rand.Intn(i) - } - return -} - -func Kira(i int) (l bool){ - lot := lottery.New(rand.New(rand.NewSource(time.Now().UnixNano()))) - if lot.Lot(i) { - l = true - } else { - l = false - } - return -} - type handler struct { *ogent.OgentHandler client *ent.Client } - -func (h handler) DrawStart(ctx context.Context, params ogent.DrawStartParams) (ogent.DrawStartNoContent, error) { - return ogent.DrawStartNoContent{}, h.client.Users.UpdateOneID(params.ID).Exec(ctx) +func (h handler) DrawStart(ctx context.Context, params ogent.DrawStartParams) error { + error := h.client.Card.UpdateOneID(params.ID).Exec(ctx) + return (error) } -func (h handler) DrawDone(ctx context.Context, params ogent.DrawDoneParams) (ogent.DrawDoneNoContent, error) { - body := h.client.Users.GetX(ctx, params.ID) - total := body.Day - total_n := total + 1 +//func (h handler) DrawDone(ctx context.Context, params ogent.DrawDoneParams) (ogent.DrawDoneNoContent, error) { +func (h handler) DrawDone(ctx context.Context, params ogent.DrawDoneParams) error { + body := h.client.Card.GetX(ctx, params.ID) + u_body := h.client.User.GetX(ctx, params.ID) jst, err := time.LoadLocation("Asia/Tokyo") if err != nil { panic(err) } t := time.Now().In(jst) tt := t.Format("20060102") - f := body.UpdatedAt.Add(time.Hour * 24 * 1).In(jst) + f := body.CreatedAt.Add(time.Hour * 24 * 1).In(jst) ff := f.Format("20060102") - fff := body.Next + fff := u_body.Next if tt < fff { - return ogent.DrawDoneNoContent{}, h.client.Users.UpdateOneID(params.ID).SetNext(ff).SetLimit(true).Exec(ctx) + error := h.client.User.UpdateOneID(params.ID).SetNext(ff).Exec(ctx) + return (error) } - - bb := h.client.Users.GetX(ctx, body.Battle) - ba := bb.Attack - aa := body.Attack - attack_p := aa - ba - win_n := body.Win + 1 - pat := float64(win_n) / float64(total_n) * 100 - var at int - if attack_p > 0 { - at = Random(55) - } else { - at = Random(45) - } - if at > 25 { - b := Random(4) - if b == 1 { - b := Random(10) - com := "attack+" + strconv.Itoa(b) - a := body.Attack + b - return ogent.DrawDoneNoContent{}, h.client.Users.UpdateOneID(params.ID).SetAttack(a).SetUpdatedAt(t).SetNext(ff).SetDay(total_n).SetWin(win_n).SetPercentage(pat).SetLimit(false).SetComment(com).Exec(ctx) - } else if b == 2 { - b := Random(10) - com := "defense+" + strconv.Itoa(b) - a := body.Defense + b - return ogent.DrawDoneNoContent{}, h.client.Users.UpdateOneID(params.ID).SetDefense(a).SetUpdatedAt(t).SetNext(ff).SetDay(total_n).SetWin(win_n).SetPercentage(pat).SetLimit(false).SetComment(com).Exec(ctx) - } else if b == 3 { - b := Random(10) - com := "hp+" + strconv.Itoa(b) - a := body.Hp + b - return ogent.DrawDoneNoContent{}, h.client.Users.UpdateOneID(params.ID).SetHp(a).SetUpdatedAt(t).SetNext(ff).SetDay(total_n).SetWin(win_n).SetPercentage(pat).SetComment(com).SetLimit(false).Exec(ctx) - } else { - b := Random(10) - com := "critical+" + strconv.Itoa(b) - a := body.Critical + b - return ogent.DrawDoneNoContent{}, h.client.Users.UpdateOneID(params.ID).SetCritical(a).SetUpdatedAt(t).SetNext(ff).SetDay(total_n).SetWin(win_n).SetPercentage(pat).SetComment(com).SetLimit(false).SetWin(win_n).Exec(ctx) - } -} else { - com := "loss" - return ogent.DrawDoneNoContent{}, h.client.Users.UpdateOneID(params.ID).SetNext(ff).SetDay(total_n).SetComment(com).SetLimit(false).Exec(ctx) -} + error := h.client.User.UpdateOneID(params.ID).SetUpdatedAt(t).Exec(ctx) + return (error) } func main() { - url := os.Getenv("DATABASE_URL") + "?sslmode=require" - client, err := ent.Open("postgres", url) - //client, err := Open(url) - if err := client.Schema.Create(context.Background(), schema.WithAtlas(true)); err != nil { + // Create ent client. + client, err := ent.Open(dialect.SQLite, "file:/data/ent.sqlite?_fk=1") + //client, err := ent.Open(dialect.SQLite, "file:data?mode=memory&cache=shared&_fk=1") + if err != nil { log.Fatal(err) } - port := os.Getenv("PORT") - if port == "" { - port = "8080" + // Run the migrations. + if err := client.Schema.Create(context.Background()); err != nil { + log.Fatal(err) } + // Create the handler. h := handler{ OgentHandler: ogent.NewOgentHandler(client), client: client, } - srv,err := ogent.NewServer(h) + // Start listening. + srv, err := ogent.NewServer(h) //srv,err := ogent.NewServer(ogent.NewOgentHandler(client)) if err != nil { log.Fatal(err) } - if err := http.ListenAndServe(":" + port, srv); err != nil { + if err := http.ListenAndServe(":8080", srv); err != nil { log.Fatal(err) } } diff --git a/readme.md b/readme.md index 22b7123..0a44834 100644 --- a/readme.md +++ b/readme.md @@ -1,34 +1,34 @@ -heroku open-api ent example - -- go-module-name : t - -- onconflict +### build ```sh -$ curl -X POST -H "Content-Type: application/json" -d '{"user":"syui"}' api.syui.cf/users -...ok +$ vim ent/entc.go +$ vim ent/schema/users.go +$ go generate ./... +$ go build +$ ./card +$ go generate ./... +$ go run -mod=mod main.go +$ curl -X POST -H "Content-Type: application/json" -d '{"username":"syui"}' localhost:8080/users +$ curl -X POST -H "Content-Type: application/json" -d '{"owner":1}' localhost:8080/cards +$ curl localhost:8080/users +$ curl localhost:8080/cards +$ curl localhost:8080/users/1 +$ curl localhost:8080/users/1/card +``` + +### use + +```sh +$ curl -X POST -H "Content-Type: application/json" -d '{"username":"syui"}' https://api.syui.ai/users + +# onconflict $ !! -...err -$ heroku logs +$ curl -sL https://api.syui.ai/users/1 ``` - -```sh -# delete -$ curl -X DELETE https://api.syui.cf/users/1 - -# card draw -$ curl -X PUT api.syui.cf/users/1/d -$ curl api.syui.cf/users/1 - -# patch -$ curl -X PATCH -H "Content-Type: application/json" -d '{"battle":2}' api.syui.cf/users/1 -$ curl -X PATCH -H "Content-Type: application/json" -d '{"limit":false}' api.syui.cf/users/1 -$ d=`date "+%Y%m%d"` -$ curl -X PATCH -H "Content-Type: application/json" -d "{\"next\":\"$d\"}" api.syui.cf/users/1 -``` +### ref ```sh $ vim ./ent/ogent/ogent.go @@ -59,20 +59,13 @@ func (h *OgentHandler) UpdateUsers(ctx context.Context, req UpdateUsersReq, para //} ``` -ref : - -- https://github.com/ent/ent/blob/master/dialect/sql/schema/postgres_test.go - -- https://github.com/go-kratos/beer-shop/tree/main/app/catalog/service/internal/data/ent +### link - https://entgo.io/ja/blog/2022/02/15/generate-rest-crud-with-ent-and-ogen/ - https://github.com/ariga/ogent/blob/main/example/todo/ent/entc.go -```sh -$ vim ent/entc.go -$ vim ent/schema/users.go -$ go generate ./... -$ go build -$ ./t -``` +- https://github.com/ent/ent/blob/master/dialect/sql/schema/postgres_test.go + +- https://github.com/go-kratos/beer-shop/tree/main/app/catalog/service/internal/data/ent +