diff --git a/build.zsh b/build.zsh index 2a40b1f..6fa36fe 100755 --- a/build.zsh +++ b/build.zsh @@ -5,6 +5,7 @@ cd $d su=5000 go generate ./... +cp -rf $d/ent/openapi.json $d/tmp/ sed -i '' "s/255/$su/g" $d/ent/ogent/oas_parameters_gen.go sed -i '' "s/255/$su/g" $d/ent/openapi.json diff --git a/ent/migrate/schema.go b/ent/migrate/schema.go index 9d66b51..a45a99a 100644 --- a/ent/migrate/schema.go +++ b/ent/migrate/schema.go @@ -91,8 +91,21 @@ var ( {Name: "ten_post", Type: field.TypeString, Nullable: true}, {Name: "ten_get", Type: field.TypeString, Nullable: true}, {Name: "ten_at", Type: field.TypeTime, Nullable: true}, - {Name: "next", Type: field.TypeString, Nullable: true, Default: "20230911"}, + {Name: "next", Type: field.TypeString, Nullable: true, Default: "20231231"}, {Name: "room", Type: field.TypeInt, Nullable: true}, + {Name: "model", Type: field.TypeBool, Nullable: true}, + {Name: "model_at", Type: field.TypeTime, Nullable: true}, + {Name: "model_attack", Type: field.TypeInt, Nullable: true}, + {Name: "model_limit", Type: field.TypeInt, Nullable: true}, + {Name: "model_skill", Type: field.TypeInt, Nullable: true}, + {Name: "model_mode", Type: field.TypeInt, Nullable: true}, + {Name: "model_critical", Type: field.TypeInt, Nullable: true}, + {Name: "model_critical_d", Type: field.TypeInt, Nullable: true}, + {Name: "game", Type: field.TypeBool, Nullable: true, Default: false}, + {Name: "game_test", Type: field.TypeBool, Nullable: true, Default: false}, + {Name: "game_end", Type: field.TypeBool, Nullable: true, Default: false}, + {Name: "game_account", Type: field.TypeBool, Nullable: true, Default: false}, + {Name: "game_lv", Type: field.TypeInt, Nullable: true}, {Name: "group_users", Type: field.TypeInt, Nullable: true}, } // UsersTable holds the schema information for the "users" table. @@ -103,7 +116,7 @@ var ( ForeignKeys: []*schema.ForeignKey{ { Symbol: "users_groups_users", - Columns: []*schema.Column{UsersColumns[35]}, + Columns: []*schema.Column{UsersColumns[48]}, RefColumns: []*schema.Column{GroupsColumns[0]}, OnDelete: schema.SetNull, }, diff --git a/ent/mutation.go b/ent/mutation.go index dfd43e6..9c3db07 100644 --- a/ent/mutation.go +++ b/ent/mutation.go @@ -1665,58 +1665,78 @@ func (m *GroupMutation) ResetEdge(name string) error { // UserMutation represents an operation that mutates the User nodes in the graph. type UserMutation struct { config - op Op - typ string - id *int - username *string - did *string - member *bool - book *bool - manga *bool - badge *bool - bsky *bool - mastodon *bool - delete *bool - handle *bool - token *string - password *string - created_at *time.Time - updated_at *time.Time - raid_at *time.Time - server_at *time.Time - egg_at *time.Time - luck *int - addluck *int - luck_at *time.Time - like *int - addlike *int - like_rank *int - addlike_rank *int - like_at *time.Time - fav *int - addfav *int - ten *bool - ten_su *int - addten_su *int - ten_kai *int - addten_kai *int - aiten *int - addaiten *int - ten_card *string - ten_delete *string - ten_post *string - ten_get *string - ten_at *time.Time - next *string - room *int - addroom *int - 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 + op Op + typ string + id *int + username *string + did *string + member *bool + book *bool + manga *bool + badge *bool + bsky *bool + mastodon *bool + delete *bool + handle *bool + token *string + password *string + created_at *time.Time + updated_at *time.Time + raid_at *time.Time + server_at *time.Time + egg_at *time.Time + luck *int + addluck *int + luck_at *time.Time + like *int + addlike *int + like_rank *int + addlike_rank *int + like_at *time.Time + fav *int + addfav *int + ten *bool + ten_su *int + addten_su *int + ten_kai *int + addten_kai *int + aiten *int + addaiten *int + ten_card *string + ten_delete *string + ten_post *string + ten_get *string + ten_at *time.Time + next *string + room *int + addroom *int + model *bool + model_at *time.Time + model_attack *int + addmodel_attack *int + model_limit *int + addmodel_limit *int + model_skill *int + addmodel_skill *int + model_mode *int + addmodel_mode *int + model_critical *int + addmodel_critical *int + model_critical_d *int + addmodel_critical_d *int + game *bool + game_test *bool + game_end *bool + game_account *bool + game_lv *int + addgame_lv *int + 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) @@ -3625,6 +3645,790 @@ func (m *UserMutation) ResetRoom() { delete(m.clearedFields, user.FieldRoom) } +// SetModel sets the "model" field. +func (m *UserMutation) SetModel(b bool) { + m.model = &b +} + +// Model returns the value of the "model" field in the mutation. +func (m *UserMutation) Model() (r bool, exists bool) { + v := m.model + if v == nil { + return + } + return *v, true +} + +// OldModel returns the old "model" 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) OldModel(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldModel is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldModel requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldModel: %w", err) + } + return oldValue.Model, nil +} + +// ClearModel clears the value of the "model" field. +func (m *UserMutation) ClearModel() { + m.model = nil + m.clearedFields[user.FieldModel] = struct{}{} +} + +// ModelCleared returns if the "model" field was cleared in this mutation. +func (m *UserMutation) ModelCleared() bool { + _, ok := m.clearedFields[user.FieldModel] + return ok +} + +// ResetModel resets all changes to the "model" field. +func (m *UserMutation) ResetModel() { + m.model = nil + delete(m.clearedFields, user.FieldModel) +} + +// SetModelAt sets the "model_at" field. +func (m *UserMutation) SetModelAt(t time.Time) { + m.model_at = &t +} + +// ModelAt returns the value of the "model_at" field in the mutation. +func (m *UserMutation) ModelAt() (r time.Time, exists bool) { + v := m.model_at + if v == nil { + return + } + return *v, true +} + +// OldModelAt returns the old "model_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) OldModelAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldModelAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldModelAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldModelAt: %w", err) + } + return oldValue.ModelAt, nil +} + +// ClearModelAt clears the value of the "model_at" field. +func (m *UserMutation) ClearModelAt() { + m.model_at = nil + m.clearedFields[user.FieldModelAt] = struct{}{} +} + +// ModelAtCleared returns if the "model_at" field was cleared in this mutation. +func (m *UserMutation) ModelAtCleared() bool { + _, ok := m.clearedFields[user.FieldModelAt] + return ok +} + +// ResetModelAt resets all changes to the "model_at" field. +func (m *UserMutation) ResetModelAt() { + m.model_at = nil + delete(m.clearedFields, user.FieldModelAt) +} + +// SetModelAttack sets the "model_attack" field. +func (m *UserMutation) SetModelAttack(i int) { + m.model_attack = &i + m.addmodel_attack = nil +} + +// ModelAttack returns the value of the "model_attack" field in the mutation. +func (m *UserMutation) ModelAttack() (r int, exists bool) { + v := m.model_attack + if v == nil { + return + } + return *v, true +} + +// OldModelAttack returns the old "model_attack" 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) OldModelAttack(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldModelAttack is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldModelAttack requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldModelAttack: %w", err) + } + return oldValue.ModelAttack, nil +} + +// AddModelAttack adds i to the "model_attack" field. +func (m *UserMutation) AddModelAttack(i int) { + if m.addmodel_attack != nil { + *m.addmodel_attack += i + } else { + m.addmodel_attack = &i + } +} + +// AddedModelAttack returns the value that was added to the "model_attack" field in this mutation. +func (m *UserMutation) AddedModelAttack() (r int, exists bool) { + v := m.addmodel_attack + if v == nil { + return + } + return *v, true +} + +// ClearModelAttack clears the value of the "model_attack" field. +func (m *UserMutation) ClearModelAttack() { + m.model_attack = nil + m.addmodel_attack = nil + m.clearedFields[user.FieldModelAttack] = struct{}{} +} + +// ModelAttackCleared returns if the "model_attack" field was cleared in this mutation. +func (m *UserMutation) ModelAttackCleared() bool { + _, ok := m.clearedFields[user.FieldModelAttack] + return ok +} + +// ResetModelAttack resets all changes to the "model_attack" field. +func (m *UserMutation) ResetModelAttack() { + m.model_attack = nil + m.addmodel_attack = nil + delete(m.clearedFields, user.FieldModelAttack) +} + +// SetModelLimit sets the "model_limit" field. +func (m *UserMutation) SetModelLimit(i int) { + m.model_limit = &i + m.addmodel_limit = nil +} + +// ModelLimit returns the value of the "model_limit" field in the mutation. +func (m *UserMutation) ModelLimit() (r int, exists bool) { + v := m.model_limit + if v == nil { + return + } + return *v, true +} + +// OldModelLimit returns the old "model_limit" 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) OldModelLimit(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldModelLimit is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldModelLimit requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldModelLimit: %w", err) + } + return oldValue.ModelLimit, nil +} + +// AddModelLimit adds i to the "model_limit" field. +func (m *UserMutation) AddModelLimit(i int) { + if m.addmodel_limit != nil { + *m.addmodel_limit += i + } else { + m.addmodel_limit = &i + } +} + +// AddedModelLimit returns the value that was added to the "model_limit" field in this mutation. +func (m *UserMutation) AddedModelLimit() (r int, exists bool) { + v := m.addmodel_limit + if v == nil { + return + } + return *v, true +} + +// ClearModelLimit clears the value of the "model_limit" field. +func (m *UserMutation) ClearModelLimit() { + m.model_limit = nil + m.addmodel_limit = nil + m.clearedFields[user.FieldModelLimit] = struct{}{} +} + +// ModelLimitCleared returns if the "model_limit" field was cleared in this mutation. +func (m *UserMutation) ModelLimitCleared() bool { + _, ok := m.clearedFields[user.FieldModelLimit] + return ok +} + +// ResetModelLimit resets all changes to the "model_limit" field. +func (m *UserMutation) ResetModelLimit() { + m.model_limit = nil + m.addmodel_limit = nil + delete(m.clearedFields, user.FieldModelLimit) +} + +// SetModelSkill sets the "model_skill" field. +func (m *UserMutation) SetModelSkill(i int) { + m.model_skill = &i + m.addmodel_skill = nil +} + +// ModelSkill returns the value of the "model_skill" field in the mutation. +func (m *UserMutation) ModelSkill() (r int, exists bool) { + v := m.model_skill + if v == nil { + return + } + return *v, true +} + +// OldModelSkill returns the old "model_skill" 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) OldModelSkill(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldModelSkill is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldModelSkill requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldModelSkill: %w", err) + } + return oldValue.ModelSkill, nil +} + +// AddModelSkill adds i to the "model_skill" field. +func (m *UserMutation) AddModelSkill(i int) { + if m.addmodel_skill != nil { + *m.addmodel_skill += i + } else { + m.addmodel_skill = &i + } +} + +// AddedModelSkill returns the value that was added to the "model_skill" field in this mutation. +func (m *UserMutation) AddedModelSkill() (r int, exists bool) { + v := m.addmodel_skill + if v == nil { + return + } + return *v, true +} + +// ClearModelSkill clears the value of the "model_skill" field. +func (m *UserMutation) ClearModelSkill() { + m.model_skill = nil + m.addmodel_skill = nil + m.clearedFields[user.FieldModelSkill] = struct{}{} +} + +// ModelSkillCleared returns if the "model_skill" field was cleared in this mutation. +func (m *UserMutation) ModelSkillCleared() bool { + _, ok := m.clearedFields[user.FieldModelSkill] + return ok +} + +// ResetModelSkill resets all changes to the "model_skill" field. +func (m *UserMutation) ResetModelSkill() { + m.model_skill = nil + m.addmodel_skill = nil + delete(m.clearedFields, user.FieldModelSkill) +} + +// SetModelMode sets the "model_mode" field. +func (m *UserMutation) SetModelMode(i int) { + m.model_mode = &i + m.addmodel_mode = nil +} + +// ModelMode returns the value of the "model_mode" field in the mutation. +func (m *UserMutation) ModelMode() (r int, exists bool) { + v := m.model_mode + if v == nil { + return + } + return *v, true +} + +// OldModelMode returns the old "model_mode" 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) OldModelMode(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldModelMode is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldModelMode requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldModelMode: %w", err) + } + return oldValue.ModelMode, nil +} + +// AddModelMode adds i to the "model_mode" field. +func (m *UserMutation) AddModelMode(i int) { + if m.addmodel_mode != nil { + *m.addmodel_mode += i + } else { + m.addmodel_mode = &i + } +} + +// AddedModelMode returns the value that was added to the "model_mode" field in this mutation. +func (m *UserMutation) AddedModelMode() (r int, exists bool) { + v := m.addmodel_mode + if v == nil { + return + } + return *v, true +} + +// ClearModelMode clears the value of the "model_mode" field. +func (m *UserMutation) ClearModelMode() { + m.model_mode = nil + m.addmodel_mode = nil + m.clearedFields[user.FieldModelMode] = struct{}{} +} + +// ModelModeCleared returns if the "model_mode" field was cleared in this mutation. +func (m *UserMutation) ModelModeCleared() bool { + _, ok := m.clearedFields[user.FieldModelMode] + return ok +} + +// ResetModelMode resets all changes to the "model_mode" field. +func (m *UserMutation) ResetModelMode() { + m.model_mode = nil + m.addmodel_mode = nil + delete(m.clearedFields, user.FieldModelMode) +} + +// SetModelCritical sets the "model_critical" field. +func (m *UserMutation) SetModelCritical(i int) { + m.model_critical = &i + m.addmodel_critical = nil +} + +// ModelCritical returns the value of the "model_critical" field in the mutation. +func (m *UserMutation) ModelCritical() (r int, exists bool) { + v := m.model_critical + if v == nil { + return + } + return *v, true +} + +// OldModelCritical returns the old "model_critical" 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) OldModelCritical(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldModelCritical is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldModelCritical requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldModelCritical: %w", err) + } + return oldValue.ModelCritical, nil +} + +// AddModelCritical adds i to the "model_critical" field. +func (m *UserMutation) AddModelCritical(i int) { + if m.addmodel_critical != nil { + *m.addmodel_critical += i + } else { + m.addmodel_critical = &i + } +} + +// AddedModelCritical returns the value that was added to the "model_critical" field in this mutation. +func (m *UserMutation) AddedModelCritical() (r int, exists bool) { + v := m.addmodel_critical + if v == nil { + return + } + return *v, true +} + +// ClearModelCritical clears the value of the "model_critical" field. +func (m *UserMutation) ClearModelCritical() { + m.model_critical = nil + m.addmodel_critical = nil + m.clearedFields[user.FieldModelCritical] = struct{}{} +} + +// ModelCriticalCleared returns if the "model_critical" field was cleared in this mutation. +func (m *UserMutation) ModelCriticalCleared() bool { + _, ok := m.clearedFields[user.FieldModelCritical] + return ok +} + +// ResetModelCritical resets all changes to the "model_critical" field. +func (m *UserMutation) ResetModelCritical() { + m.model_critical = nil + m.addmodel_critical = nil + delete(m.clearedFields, user.FieldModelCritical) +} + +// SetModelCriticalD sets the "model_critical_d" field. +func (m *UserMutation) SetModelCriticalD(i int) { + m.model_critical_d = &i + m.addmodel_critical_d = nil +} + +// ModelCriticalD returns the value of the "model_critical_d" field in the mutation. +func (m *UserMutation) ModelCriticalD() (r int, exists bool) { + v := m.model_critical_d + if v == nil { + return + } + return *v, true +} + +// OldModelCriticalD returns the old "model_critical_d" 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) OldModelCriticalD(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldModelCriticalD is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldModelCriticalD requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldModelCriticalD: %w", err) + } + return oldValue.ModelCriticalD, nil +} + +// AddModelCriticalD adds i to the "model_critical_d" field. +func (m *UserMutation) AddModelCriticalD(i int) { + if m.addmodel_critical_d != nil { + *m.addmodel_critical_d += i + } else { + m.addmodel_critical_d = &i + } +} + +// AddedModelCriticalD returns the value that was added to the "model_critical_d" field in this mutation. +func (m *UserMutation) AddedModelCriticalD() (r int, exists bool) { + v := m.addmodel_critical_d + if v == nil { + return + } + return *v, true +} + +// ClearModelCriticalD clears the value of the "model_critical_d" field. +func (m *UserMutation) ClearModelCriticalD() { + m.model_critical_d = nil + m.addmodel_critical_d = nil + m.clearedFields[user.FieldModelCriticalD] = struct{}{} +} + +// ModelCriticalDCleared returns if the "model_critical_d" field was cleared in this mutation. +func (m *UserMutation) ModelCriticalDCleared() bool { + _, ok := m.clearedFields[user.FieldModelCriticalD] + return ok +} + +// ResetModelCriticalD resets all changes to the "model_critical_d" field. +func (m *UserMutation) ResetModelCriticalD() { + m.model_critical_d = nil + m.addmodel_critical_d = nil + delete(m.clearedFields, user.FieldModelCriticalD) +} + +// SetGame sets the "game" field. +func (m *UserMutation) SetGame(b bool) { + m.game = &b +} + +// Game returns the value of the "game" field in the mutation. +func (m *UserMutation) Game() (r bool, exists bool) { + v := m.game + if v == nil { + return + } + return *v, true +} + +// OldGame returns the old "game" 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) OldGame(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldGame is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldGame requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldGame: %w", err) + } + return oldValue.Game, nil +} + +// ClearGame clears the value of the "game" field. +func (m *UserMutation) ClearGame() { + m.game = nil + m.clearedFields[user.FieldGame] = struct{}{} +} + +// GameCleared returns if the "game" field was cleared in this mutation. +func (m *UserMutation) GameCleared() bool { + _, ok := m.clearedFields[user.FieldGame] + return ok +} + +// ResetGame resets all changes to the "game" field. +func (m *UserMutation) ResetGame() { + m.game = nil + delete(m.clearedFields, user.FieldGame) +} + +// SetGameTest sets the "game_test" field. +func (m *UserMutation) SetGameTest(b bool) { + m.game_test = &b +} + +// GameTest returns the value of the "game_test" field in the mutation. +func (m *UserMutation) GameTest() (r bool, exists bool) { + v := m.game_test + if v == nil { + return + } + return *v, true +} + +// OldGameTest returns the old "game_test" 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) OldGameTest(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldGameTest is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldGameTest requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldGameTest: %w", err) + } + return oldValue.GameTest, nil +} + +// ClearGameTest clears the value of the "game_test" field. +func (m *UserMutation) ClearGameTest() { + m.game_test = nil + m.clearedFields[user.FieldGameTest] = struct{}{} +} + +// GameTestCleared returns if the "game_test" field was cleared in this mutation. +func (m *UserMutation) GameTestCleared() bool { + _, ok := m.clearedFields[user.FieldGameTest] + return ok +} + +// ResetGameTest resets all changes to the "game_test" field. +func (m *UserMutation) ResetGameTest() { + m.game_test = nil + delete(m.clearedFields, user.FieldGameTest) +} + +// SetGameEnd sets the "game_end" field. +func (m *UserMutation) SetGameEnd(b bool) { + m.game_end = &b +} + +// GameEnd returns the value of the "game_end" field in the mutation. +func (m *UserMutation) GameEnd() (r bool, exists bool) { + v := m.game_end + if v == nil { + return + } + return *v, true +} + +// OldGameEnd returns the old "game_end" 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) OldGameEnd(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldGameEnd is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldGameEnd requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldGameEnd: %w", err) + } + return oldValue.GameEnd, nil +} + +// ClearGameEnd clears the value of the "game_end" field. +func (m *UserMutation) ClearGameEnd() { + m.game_end = nil + m.clearedFields[user.FieldGameEnd] = struct{}{} +} + +// GameEndCleared returns if the "game_end" field was cleared in this mutation. +func (m *UserMutation) GameEndCleared() bool { + _, ok := m.clearedFields[user.FieldGameEnd] + return ok +} + +// ResetGameEnd resets all changes to the "game_end" field. +func (m *UserMutation) ResetGameEnd() { + m.game_end = nil + delete(m.clearedFields, user.FieldGameEnd) +} + +// SetGameAccount sets the "game_account" field. +func (m *UserMutation) SetGameAccount(b bool) { + m.game_account = &b +} + +// GameAccount returns the value of the "game_account" field in the mutation. +func (m *UserMutation) GameAccount() (r bool, exists bool) { + v := m.game_account + if v == nil { + return + } + return *v, true +} + +// OldGameAccount returns the old "game_account" 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) OldGameAccount(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldGameAccount is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldGameAccount requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldGameAccount: %w", err) + } + return oldValue.GameAccount, nil +} + +// ClearGameAccount clears the value of the "game_account" field. +func (m *UserMutation) ClearGameAccount() { + m.game_account = nil + m.clearedFields[user.FieldGameAccount] = struct{}{} +} + +// GameAccountCleared returns if the "game_account" field was cleared in this mutation. +func (m *UserMutation) GameAccountCleared() bool { + _, ok := m.clearedFields[user.FieldGameAccount] + return ok +} + +// ResetGameAccount resets all changes to the "game_account" field. +func (m *UserMutation) ResetGameAccount() { + m.game_account = nil + delete(m.clearedFields, user.FieldGameAccount) +} + +// SetGameLv sets the "game_lv" field. +func (m *UserMutation) SetGameLv(i int) { + m.game_lv = &i + m.addgame_lv = nil +} + +// GameLv returns the value of the "game_lv" field in the mutation. +func (m *UserMutation) GameLv() (r int, exists bool) { + v := m.game_lv + if v == nil { + return + } + return *v, true +} + +// OldGameLv returns the old "game_lv" 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) OldGameLv(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldGameLv is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldGameLv requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldGameLv: %w", err) + } + return oldValue.GameLv, nil +} + +// AddGameLv adds i to the "game_lv" field. +func (m *UserMutation) AddGameLv(i int) { + if m.addgame_lv != nil { + *m.addgame_lv += i + } else { + m.addgame_lv = &i + } +} + +// AddedGameLv returns the value that was added to the "game_lv" field in this mutation. +func (m *UserMutation) AddedGameLv() (r int, exists bool) { + v := m.addgame_lv + if v == nil { + return + } + return *v, true +} + +// ClearGameLv clears the value of the "game_lv" field. +func (m *UserMutation) ClearGameLv() { + m.game_lv = nil + m.addgame_lv = nil + m.clearedFields[user.FieldGameLv] = struct{}{} +} + +// GameLvCleared returns if the "game_lv" field was cleared in this mutation. +func (m *UserMutation) GameLvCleared() bool { + _, ok := m.clearedFields[user.FieldGameLv] + return ok +} + +// ResetGameLv resets all changes to the "game_lv" field. +func (m *UserMutation) ResetGameLv() { + m.game_lv = nil + m.addgame_lv = nil + delete(m.clearedFields, user.FieldGameLv) +} + // AddCardIDs adds the "card" edge to the Card entity by ids. func (m *UserMutation) AddCardIDs(ids ...int) { if m.card == nil { @@ -3713,7 +4517,7 @@ func (m *UserMutation) Type() string { // order to get all numeric fields that were incremented/decremented, call // AddedFields(). func (m *UserMutation) Fields() []string { - fields := make([]string, 0, 34) + fields := make([]string, 0, 47) if m.username != nil { fields = append(fields, user.FieldUsername) } @@ -3816,6 +4620,45 @@ func (m *UserMutation) Fields() []string { if m.room != nil { fields = append(fields, user.FieldRoom) } + if m.model != nil { + fields = append(fields, user.FieldModel) + } + if m.model_at != nil { + fields = append(fields, user.FieldModelAt) + } + if m.model_attack != nil { + fields = append(fields, user.FieldModelAttack) + } + if m.model_limit != nil { + fields = append(fields, user.FieldModelLimit) + } + if m.model_skill != nil { + fields = append(fields, user.FieldModelSkill) + } + if m.model_mode != nil { + fields = append(fields, user.FieldModelMode) + } + if m.model_critical != nil { + fields = append(fields, user.FieldModelCritical) + } + if m.model_critical_d != nil { + fields = append(fields, user.FieldModelCriticalD) + } + if m.game != nil { + fields = append(fields, user.FieldGame) + } + if m.game_test != nil { + fields = append(fields, user.FieldGameTest) + } + if m.game_end != nil { + fields = append(fields, user.FieldGameEnd) + } + if m.game_account != nil { + fields = append(fields, user.FieldGameAccount) + } + if m.game_lv != nil { + fields = append(fields, user.FieldGameLv) + } return fields } @@ -3892,6 +4735,32 @@ func (m *UserMutation) Field(name string) (ent.Value, bool) { return m.Next() case user.FieldRoom: return m.Room() + case user.FieldModel: + return m.Model() + case user.FieldModelAt: + return m.ModelAt() + case user.FieldModelAttack: + return m.ModelAttack() + case user.FieldModelLimit: + return m.ModelLimit() + case user.FieldModelSkill: + return m.ModelSkill() + case user.FieldModelMode: + return m.ModelMode() + case user.FieldModelCritical: + return m.ModelCritical() + case user.FieldModelCriticalD: + return m.ModelCriticalD() + case user.FieldGame: + return m.Game() + case user.FieldGameTest: + return m.GameTest() + case user.FieldGameEnd: + return m.GameEnd() + case user.FieldGameAccount: + return m.GameAccount() + case user.FieldGameLv: + return m.GameLv() } return nil, false } @@ -3969,6 +4838,32 @@ func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, er return m.OldNext(ctx) case user.FieldRoom: return m.OldRoom(ctx) + case user.FieldModel: + return m.OldModel(ctx) + case user.FieldModelAt: + return m.OldModelAt(ctx) + case user.FieldModelAttack: + return m.OldModelAttack(ctx) + case user.FieldModelLimit: + return m.OldModelLimit(ctx) + case user.FieldModelSkill: + return m.OldModelSkill(ctx) + case user.FieldModelMode: + return m.OldModelMode(ctx) + case user.FieldModelCritical: + return m.OldModelCritical(ctx) + case user.FieldModelCriticalD: + return m.OldModelCriticalD(ctx) + case user.FieldGame: + return m.OldGame(ctx) + case user.FieldGameTest: + return m.OldGameTest(ctx) + case user.FieldGameEnd: + return m.OldGameEnd(ctx) + case user.FieldGameAccount: + return m.OldGameAccount(ctx) + case user.FieldGameLv: + return m.OldGameLv(ctx) } return nil, fmt.Errorf("unknown User field %s", name) } @@ -4216,6 +5111,97 @@ func (m *UserMutation) SetField(name string, value ent.Value) error { } m.SetRoom(v) return nil + case user.FieldModel: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetModel(v) + return nil + case user.FieldModelAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetModelAt(v) + return nil + case user.FieldModelAttack: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetModelAttack(v) + return nil + case user.FieldModelLimit: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetModelLimit(v) + return nil + case user.FieldModelSkill: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetModelSkill(v) + return nil + case user.FieldModelMode: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetModelMode(v) + return nil + case user.FieldModelCritical: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetModelCritical(v) + return nil + case user.FieldModelCriticalD: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetModelCriticalD(v) + return nil + case user.FieldGame: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetGame(v) + return nil + case user.FieldGameTest: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetGameTest(v) + return nil + case user.FieldGameEnd: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetGameEnd(v) + return nil + case user.FieldGameAccount: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetGameAccount(v) + return nil + case user.FieldGameLv: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetGameLv(v) + return nil } return fmt.Errorf("unknown User field %s", name) } @@ -4248,6 +5234,27 @@ func (m *UserMutation) AddedFields() []string { if m.addroom != nil { fields = append(fields, user.FieldRoom) } + if m.addmodel_attack != nil { + fields = append(fields, user.FieldModelAttack) + } + if m.addmodel_limit != nil { + fields = append(fields, user.FieldModelLimit) + } + if m.addmodel_skill != nil { + fields = append(fields, user.FieldModelSkill) + } + if m.addmodel_mode != nil { + fields = append(fields, user.FieldModelMode) + } + if m.addmodel_critical != nil { + fields = append(fields, user.FieldModelCritical) + } + if m.addmodel_critical_d != nil { + fields = append(fields, user.FieldModelCriticalD) + } + if m.addgame_lv != nil { + fields = append(fields, user.FieldGameLv) + } return fields } @@ -4272,6 +5279,20 @@ func (m *UserMutation) AddedField(name string) (ent.Value, bool) { return m.AddedAiten() case user.FieldRoom: return m.AddedRoom() + case user.FieldModelAttack: + return m.AddedModelAttack() + case user.FieldModelLimit: + return m.AddedModelLimit() + case user.FieldModelSkill: + return m.AddedModelSkill() + case user.FieldModelMode: + return m.AddedModelMode() + case user.FieldModelCritical: + return m.AddedModelCritical() + case user.FieldModelCriticalD: + return m.AddedModelCriticalD() + case user.FieldGameLv: + return m.AddedGameLv() } return nil, false } @@ -4337,6 +5358,55 @@ func (m *UserMutation) AddField(name string, value ent.Value) error { } m.AddRoom(v) return nil + case user.FieldModelAttack: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddModelAttack(v) + return nil + case user.FieldModelLimit: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddModelLimit(v) + return nil + case user.FieldModelSkill: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddModelSkill(v) + return nil + case user.FieldModelMode: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddModelMode(v) + return nil + case user.FieldModelCritical: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddModelCritical(v) + return nil + case user.FieldModelCriticalD: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddModelCriticalD(v) + return nil + case user.FieldGameLv: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddGameLv(v) + return nil } return fmt.Errorf("unknown User numeric field %s", name) } @@ -4441,6 +5511,45 @@ func (m *UserMutation) ClearedFields() []string { if m.FieldCleared(user.FieldRoom) { fields = append(fields, user.FieldRoom) } + if m.FieldCleared(user.FieldModel) { + fields = append(fields, user.FieldModel) + } + if m.FieldCleared(user.FieldModelAt) { + fields = append(fields, user.FieldModelAt) + } + if m.FieldCleared(user.FieldModelAttack) { + fields = append(fields, user.FieldModelAttack) + } + if m.FieldCleared(user.FieldModelLimit) { + fields = append(fields, user.FieldModelLimit) + } + if m.FieldCleared(user.FieldModelSkill) { + fields = append(fields, user.FieldModelSkill) + } + if m.FieldCleared(user.FieldModelMode) { + fields = append(fields, user.FieldModelMode) + } + if m.FieldCleared(user.FieldModelCritical) { + fields = append(fields, user.FieldModelCritical) + } + if m.FieldCleared(user.FieldModelCriticalD) { + fields = append(fields, user.FieldModelCriticalD) + } + if m.FieldCleared(user.FieldGame) { + fields = append(fields, user.FieldGame) + } + if m.FieldCleared(user.FieldGameTest) { + fields = append(fields, user.FieldGameTest) + } + if m.FieldCleared(user.FieldGameEnd) { + fields = append(fields, user.FieldGameEnd) + } + if m.FieldCleared(user.FieldGameAccount) { + fields = append(fields, user.FieldGameAccount) + } + if m.FieldCleared(user.FieldGameLv) { + fields = append(fields, user.FieldGameLv) + } return fields } @@ -4551,6 +5660,45 @@ func (m *UserMutation) ClearField(name string) error { case user.FieldRoom: m.ClearRoom() return nil + case user.FieldModel: + m.ClearModel() + return nil + case user.FieldModelAt: + m.ClearModelAt() + return nil + case user.FieldModelAttack: + m.ClearModelAttack() + return nil + case user.FieldModelLimit: + m.ClearModelLimit() + return nil + case user.FieldModelSkill: + m.ClearModelSkill() + return nil + case user.FieldModelMode: + m.ClearModelMode() + return nil + case user.FieldModelCritical: + m.ClearModelCritical() + return nil + case user.FieldModelCriticalD: + m.ClearModelCriticalD() + return nil + case user.FieldGame: + m.ClearGame() + return nil + case user.FieldGameTest: + m.ClearGameTest() + return nil + case user.FieldGameEnd: + m.ClearGameEnd() + return nil + case user.FieldGameAccount: + m.ClearGameAccount() + return nil + case user.FieldGameLv: + m.ClearGameLv() + return nil } return fmt.Errorf("unknown User nullable field %s", name) } @@ -4661,6 +5809,45 @@ func (m *UserMutation) ResetField(name string) error { case user.FieldRoom: m.ResetRoom() return nil + case user.FieldModel: + m.ResetModel() + return nil + case user.FieldModelAt: + m.ResetModelAt() + return nil + case user.FieldModelAttack: + m.ResetModelAttack() + return nil + case user.FieldModelLimit: + m.ResetModelLimit() + return nil + case user.FieldModelSkill: + m.ResetModelSkill() + return nil + case user.FieldModelMode: + m.ResetModelMode() + return nil + case user.FieldModelCritical: + m.ResetModelCritical() + return nil + case user.FieldModelCriticalD: + m.ResetModelCriticalD() + return nil + case user.FieldGame: + m.ResetGame() + return nil + case user.FieldGameTest: + m.ResetGameTest() + return nil + case user.FieldGameEnd: + m.ResetGameEnd() + return nil + case user.FieldGameAccount: + m.ResetGameAccount() + return nil + case user.FieldGameLv: + m.ResetGameLv() + return nil } return fmt.Errorf("unknown User field %s", name) } diff --git a/ent/ogent/oas_json_gen.go b/ent/ogent/oas_json_gen.go index e10788f..58be669 100644 --- a/ent/ogent/oas_json_gen.go +++ b/ent/ogent/oas_json_gen.go @@ -687,9 +687,87 @@ func (s *CardOwnerRead) encodeFields(e *jx.Encoder) { s.Room.Encode(e) } } + { + if s.Model.Set { + e.FieldStart("model") + s.Model.Encode(e) + } + } + { + if s.ModelAt.Set { + e.FieldStart("model_at") + s.ModelAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.ModelAttack.Set { + e.FieldStart("model_attack") + s.ModelAttack.Encode(e) + } + } + { + if s.ModelLimit.Set { + e.FieldStart("model_limit") + s.ModelLimit.Encode(e) + } + } + { + if s.ModelSkill.Set { + e.FieldStart("model_skill") + s.ModelSkill.Encode(e) + } + } + { + if s.ModelMode.Set { + e.FieldStart("model_mode") + s.ModelMode.Encode(e) + } + } + { + if s.ModelCritical.Set { + e.FieldStart("model_critical") + s.ModelCritical.Encode(e) + } + } + { + if s.ModelCriticalD.Set { + e.FieldStart("model_critical_d") + s.ModelCriticalD.Encode(e) + } + } + { + if s.Game.Set { + e.FieldStart("game") + s.Game.Encode(e) + } + } + { + if s.GameTest.Set { + e.FieldStart("game_test") + s.GameTest.Encode(e) + } + } + { + if s.GameEnd.Set { + e.FieldStart("game_end") + s.GameEnd.Encode(e) + } + } + { + if s.GameAccount.Set { + e.FieldStart("game_account") + s.GameAccount.Encode(e) + } + } + { + if s.GameLv.Set { + e.FieldStart("game_lv") + s.GameLv.Encode(e) + } + } } -var jsonFieldsNameOfCardOwnerRead = [33]string{ +var jsonFieldsNameOfCardOwnerRead = [46]string{ 0: "id", 1: "username", 2: "did", @@ -723,6 +801,19 @@ var jsonFieldsNameOfCardOwnerRead = [33]string{ 30: "ten_at", 31: "next", 32: "room", + 33: "model", + 34: "model_at", + 35: "model_attack", + 36: "model_limit", + 37: "model_skill", + 38: "model_mode", + 39: "model_critical", + 40: "model_critical_d", + 41: "game", + 42: "game_test", + 43: "game_end", + 44: "game_account", + 45: "game_lv", } // Decode decodes CardOwnerRead from json. @@ -730,7 +821,7 @@ func (s *CardOwnerRead) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode CardOwnerRead to nil") } - var requiredBitSet [5]uint8 + var requiredBitSet [6]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -1068,6 +1159,136 @@ func (s *CardOwnerRead) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"room\"") } + case "model": + if err := func() error { + s.Model.Reset() + if err := s.Model.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model\"") + } + case "model_at": + if err := func() error { + s.ModelAt.Reset() + if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_at\"") + } + case "model_attack": + if err := func() error { + s.ModelAttack.Reset() + if err := s.ModelAttack.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_attack\"") + } + case "model_limit": + if err := func() error { + s.ModelLimit.Reset() + if err := s.ModelLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_limit\"") + } + case "model_skill": + if err := func() error { + s.ModelSkill.Reset() + if err := s.ModelSkill.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_skill\"") + } + case "model_mode": + if err := func() error { + s.ModelMode.Reset() + if err := s.ModelMode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_mode\"") + } + case "model_critical": + if err := func() error { + s.ModelCritical.Reset() + if err := s.ModelCritical.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical\"") + } + case "model_critical_d": + if err := func() error { + s.ModelCriticalD.Reset() + if err := s.ModelCriticalD.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical_d\"") + } + case "game": + if err := func() error { + s.Game.Reset() + if err := s.Game.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game\"") + } + case "game_test": + if err := func() error { + s.GameTest.Reset() + if err := s.GameTest.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_test\"") + } + case "game_end": + if err := func() error { + s.GameEnd.Reset() + if err := s.GameEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_end\"") + } + case "game_account": + if err := func() error { + s.GameAccount.Reset() + if err := s.GameAccount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_account\"") + } + case "game_lv": + if err := func() error { + s.GameLv.Reset() + if err := s.GameLv.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_lv\"") + } default: return d.Skip() } @@ -1077,12 +1298,13 @@ func (s *CardOwnerRead) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [5]uint8{ + for i, mask := range [6]uint8{ 0b00000011, 0b00000000, 0b00000000, 0b00000000, 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -2221,6 +2443,84 @@ func (s *CreateUserReq) encodeFields(e *jx.Encoder) { s.Room.Encode(e) } } + { + if s.Model.Set { + e.FieldStart("model") + s.Model.Encode(e) + } + } + { + if s.ModelAt.Set { + e.FieldStart("model_at") + s.ModelAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.ModelAttack.Set { + e.FieldStart("model_attack") + s.ModelAttack.Encode(e) + } + } + { + if s.ModelLimit.Set { + e.FieldStart("model_limit") + s.ModelLimit.Encode(e) + } + } + { + if s.ModelSkill.Set { + e.FieldStart("model_skill") + s.ModelSkill.Encode(e) + } + } + { + if s.ModelMode.Set { + e.FieldStart("model_mode") + s.ModelMode.Encode(e) + } + } + { + if s.ModelCritical.Set { + e.FieldStart("model_critical") + s.ModelCritical.Encode(e) + } + } + { + if s.ModelCriticalD.Set { + e.FieldStart("model_critical_d") + s.ModelCriticalD.Encode(e) + } + } + { + if s.Game.Set { + e.FieldStart("game") + s.Game.Encode(e) + } + } + { + if s.GameTest.Set { + e.FieldStart("game_test") + s.GameTest.Encode(e) + } + } + { + if s.GameEnd.Set { + e.FieldStart("game_end") + s.GameEnd.Encode(e) + } + } + { + if s.GameAccount.Set { + e.FieldStart("game_account") + s.GameAccount.Encode(e) + } + } + { + if s.GameLv.Set { + e.FieldStart("game_lv") + s.GameLv.Encode(e) + } + } { if s.Card != nil { e.FieldStart("card") @@ -2233,7 +2533,7 @@ func (s *CreateUserReq) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfCreateUserReq = [35]string{ +var jsonFieldsNameOfCreateUserReq = [48]string{ 0: "username", 1: "did", 2: "member", @@ -2268,7 +2568,20 @@ var jsonFieldsNameOfCreateUserReq = [35]string{ 31: "ten_at", 32: "next", 33: "room", - 34: "card", + 34: "model", + 35: "model_at", + 36: "model_attack", + 37: "model_limit", + 38: "model_skill", + 39: "model_mode", + 40: "model_critical", + 41: "model_critical_d", + 42: "game", + 43: "game_test", + 44: "game_end", + 45: "game_account", + 46: "game_lv", + 47: "card", } // Decode decodes CreateUserReq from json. @@ -2276,7 +2589,7 @@ func (s *CreateUserReq) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode CreateUserReq to nil") } - var requiredBitSet [5]uint8 + var requiredBitSet [6]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -2624,6 +2937,136 @@ func (s *CreateUserReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"room\"") } + case "model": + if err := func() error { + s.Model.Reset() + if err := s.Model.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model\"") + } + case "model_at": + if err := func() error { + s.ModelAt.Reset() + if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_at\"") + } + case "model_attack": + if err := func() error { + s.ModelAttack.Reset() + if err := s.ModelAttack.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_attack\"") + } + case "model_limit": + if err := func() error { + s.ModelLimit.Reset() + if err := s.ModelLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_limit\"") + } + case "model_skill": + if err := func() error { + s.ModelSkill.Reset() + if err := s.ModelSkill.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_skill\"") + } + case "model_mode": + if err := func() error { + s.ModelMode.Reset() + if err := s.ModelMode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_mode\"") + } + case "model_critical": + if err := func() error { + s.ModelCritical.Reset() + if err := s.ModelCritical.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical\"") + } + case "model_critical_d": + if err := func() error { + s.ModelCriticalD.Reset() + if err := s.ModelCriticalD.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical_d\"") + } + case "game": + if err := func() error { + s.Game.Reset() + if err := s.Game.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game\"") + } + case "game_test": + if err := func() error { + s.GameTest.Reset() + if err := s.GameTest.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_test\"") + } + case "game_end": + if err := func() error { + s.GameEnd.Reset() + if err := s.GameEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_end\"") + } + case "game_account": + if err := func() error { + s.GameAccount.Reset() + if err := s.GameAccount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_account\"") + } + case "game_lv": + if err := func() error { + s.GameLv.Reset() + if err := s.GameLv.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_lv\"") + } case "card": if err := func() error { s.Card = make([]int, 0) @@ -2652,12 +3095,13 @@ func (s *CreateUserReq) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [5]uint8{ + for i, mask := range [6]uint8{ 0b00000001, 0b00001000, 0b00000000, 0b00000000, 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -3368,9 +3812,87 @@ func (s *GroupUsersList) encodeFields(e *jx.Encoder) { s.Room.Encode(e) } } + { + if s.Model.Set { + e.FieldStart("model") + s.Model.Encode(e) + } + } + { + if s.ModelAt.Set { + e.FieldStart("model_at") + s.ModelAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.ModelAttack.Set { + e.FieldStart("model_attack") + s.ModelAttack.Encode(e) + } + } + { + if s.ModelLimit.Set { + e.FieldStart("model_limit") + s.ModelLimit.Encode(e) + } + } + { + if s.ModelSkill.Set { + e.FieldStart("model_skill") + s.ModelSkill.Encode(e) + } + } + { + if s.ModelMode.Set { + e.FieldStart("model_mode") + s.ModelMode.Encode(e) + } + } + { + if s.ModelCritical.Set { + e.FieldStart("model_critical") + s.ModelCritical.Encode(e) + } + } + { + if s.ModelCriticalD.Set { + e.FieldStart("model_critical_d") + s.ModelCriticalD.Encode(e) + } + } + { + if s.Game.Set { + e.FieldStart("game") + s.Game.Encode(e) + } + } + { + if s.GameTest.Set { + e.FieldStart("game_test") + s.GameTest.Encode(e) + } + } + { + if s.GameEnd.Set { + e.FieldStart("game_end") + s.GameEnd.Encode(e) + } + } + { + if s.GameAccount.Set { + e.FieldStart("game_account") + s.GameAccount.Encode(e) + } + } + { + if s.GameLv.Set { + e.FieldStart("game_lv") + s.GameLv.Encode(e) + } + } } -var jsonFieldsNameOfGroupUsersList = [33]string{ +var jsonFieldsNameOfGroupUsersList = [46]string{ 0: "id", 1: "username", 2: "did", @@ -3404,6 +3926,19 @@ var jsonFieldsNameOfGroupUsersList = [33]string{ 30: "ten_at", 31: "next", 32: "room", + 33: "model", + 34: "model_at", + 35: "model_attack", + 36: "model_limit", + 37: "model_skill", + 38: "model_mode", + 39: "model_critical", + 40: "model_critical_d", + 41: "game", + 42: "game_test", + 43: "game_end", + 44: "game_account", + 45: "game_lv", } // Decode decodes GroupUsersList from json. @@ -3411,7 +3946,7 @@ func (s *GroupUsersList) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode GroupUsersList to nil") } - var requiredBitSet [5]uint8 + var requiredBitSet [6]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -3749,6 +4284,136 @@ func (s *GroupUsersList) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"room\"") } + case "model": + if err := func() error { + s.Model.Reset() + if err := s.Model.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model\"") + } + case "model_at": + if err := func() error { + s.ModelAt.Reset() + if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_at\"") + } + case "model_attack": + if err := func() error { + s.ModelAttack.Reset() + if err := s.ModelAttack.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_attack\"") + } + case "model_limit": + if err := func() error { + s.ModelLimit.Reset() + if err := s.ModelLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_limit\"") + } + case "model_skill": + if err := func() error { + s.ModelSkill.Reset() + if err := s.ModelSkill.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_skill\"") + } + case "model_mode": + if err := func() error { + s.ModelMode.Reset() + if err := s.ModelMode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_mode\"") + } + case "model_critical": + if err := func() error { + s.ModelCritical.Reset() + if err := s.ModelCritical.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical\"") + } + case "model_critical_d": + if err := func() error { + s.ModelCriticalD.Reset() + if err := s.ModelCriticalD.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical_d\"") + } + case "game": + if err := func() error { + s.Game.Reset() + if err := s.Game.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game\"") + } + case "game_test": + if err := func() error { + s.GameTest.Reset() + if err := s.GameTest.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_test\"") + } + case "game_end": + if err := func() error { + s.GameEnd.Reset() + if err := s.GameEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_end\"") + } + case "game_account": + if err := func() error { + s.GameAccount.Reset() + if err := s.GameAccount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_account\"") + } + case "game_lv": + if err := func() error { + s.GameLv.Reset() + if err := s.GameLv.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_lv\"") + } default: return d.Skip() } @@ -3758,12 +4423,13 @@ func (s *GroupUsersList) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [5]uint8{ + for i, mask := range [6]uint8{ 0b00000011, 0b00000000, 0b00000000, 0b00000000, 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -5222,6 +5888,84 @@ func (s *UpdateUserReq) encodeFields(e *jx.Encoder) { s.Room.Encode(e) } } + { + if s.Model.Set { + e.FieldStart("model") + s.Model.Encode(e) + } + } + { + if s.ModelAt.Set { + e.FieldStart("model_at") + s.ModelAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.ModelAttack.Set { + e.FieldStart("model_attack") + s.ModelAttack.Encode(e) + } + } + { + if s.ModelLimit.Set { + e.FieldStart("model_limit") + s.ModelLimit.Encode(e) + } + } + { + if s.ModelSkill.Set { + e.FieldStart("model_skill") + s.ModelSkill.Encode(e) + } + } + { + if s.ModelMode.Set { + e.FieldStart("model_mode") + s.ModelMode.Encode(e) + } + } + { + if s.ModelCritical.Set { + e.FieldStart("model_critical") + s.ModelCritical.Encode(e) + } + } + { + if s.ModelCriticalD.Set { + e.FieldStart("model_critical_d") + s.ModelCriticalD.Encode(e) + } + } + { + if s.Game.Set { + e.FieldStart("game") + s.Game.Encode(e) + } + } + { + if s.GameTest.Set { + e.FieldStart("game_test") + s.GameTest.Encode(e) + } + } + { + if s.GameEnd.Set { + e.FieldStart("game_end") + s.GameEnd.Encode(e) + } + } + { + if s.GameAccount.Set { + e.FieldStart("game_account") + s.GameAccount.Encode(e) + } + } + { + if s.GameLv.Set { + e.FieldStart("game_lv") + s.GameLv.Encode(e) + } + } { if s.Card != nil { e.FieldStart("card") @@ -5234,7 +5978,7 @@ func (s *UpdateUserReq) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfUpdateUserReq = [32]string{ +var jsonFieldsNameOfUpdateUserReq = [45]string{ 0: "did", 1: "member", 2: "book", @@ -5266,7 +6010,20 @@ var jsonFieldsNameOfUpdateUserReq = [32]string{ 28: "ten_at", 29: "next", 30: "room", - 31: "card", + 31: "model", + 32: "model_at", + 33: "model_attack", + 34: "model_limit", + 35: "model_skill", + 36: "model_mode", + 37: "model_critical", + 38: "model_critical_d", + 39: "game", + 40: "game_test", + 41: "game_end", + 42: "game_account", + 43: "game_lv", + 44: "card", } // Decode decodes UpdateUserReq from json. @@ -5587,6 +6344,136 @@ func (s *UpdateUserReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"room\"") } + case "model": + if err := func() error { + s.Model.Reset() + if err := s.Model.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model\"") + } + case "model_at": + if err := func() error { + s.ModelAt.Reset() + if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_at\"") + } + case "model_attack": + if err := func() error { + s.ModelAttack.Reset() + if err := s.ModelAttack.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_attack\"") + } + case "model_limit": + if err := func() error { + s.ModelLimit.Reset() + if err := s.ModelLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_limit\"") + } + case "model_skill": + if err := func() error { + s.ModelSkill.Reset() + if err := s.ModelSkill.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_skill\"") + } + case "model_mode": + if err := func() error { + s.ModelMode.Reset() + if err := s.ModelMode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_mode\"") + } + case "model_critical": + if err := func() error { + s.ModelCritical.Reset() + if err := s.ModelCritical.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical\"") + } + case "model_critical_d": + if err := func() error { + s.ModelCriticalD.Reset() + if err := s.ModelCriticalD.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical_d\"") + } + case "game": + if err := func() error { + s.Game.Reset() + if err := s.Game.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game\"") + } + case "game_test": + if err := func() error { + s.GameTest.Reset() + if err := s.GameTest.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_test\"") + } + case "game_end": + if err := func() error { + s.GameEnd.Reset() + if err := s.GameEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_end\"") + } + case "game_account": + if err := func() error { + s.GameAccount.Reset() + if err := s.GameAccount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_account\"") + } + case "game_lv": + if err := func() error { + s.GameLv.Reset() + if err := s.GameLv.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_lv\"") + } case "card": if err := func() error { s.Card = make([]int, 0) @@ -6069,9 +6956,87 @@ func (s *UserCreate) encodeFields(e *jx.Encoder) { s.Room.Encode(e) } } + { + if s.Model.Set { + e.FieldStart("model") + s.Model.Encode(e) + } + } + { + if s.ModelAt.Set { + e.FieldStart("model_at") + s.ModelAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.ModelAttack.Set { + e.FieldStart("model_attack") + s.ModelAttack.Encode(e) + } + } + { + if s.ModelLimit.Set { + e.FieldStart("model_limit") + s.ModelLimit.Encode(e) + } + } + { + if s.ModelSkill.Set { + e.FieldStart("model_skill") + s.ModelSkill.Encode(e) + } + } + { + if s.ModelMode.Set { + e.FieldStart("model_mode") + s.ModelMode.Encode(e) + } + } + { + if s.ModelCritical.Set { + e.FieldStart("model_critical") + s.ModelCritical.Encode(e) + } + } + { + if s.ModelCriticalD.Set { + e.FieldStart("model_critical_d") + s.ModelCriticalD.Encode(e) + } + } + { + if s.Game.Set { + e.FieldStart("game") + s.Game.Encode(e) + } + } + { + if s.GameTest.Set { + e.FieldStart("game_test") + s.GameTest.Encode(e) + } + } + { + if s.GameEnd.Set { + e.FieldStart("game_end") + s.GameEnd.Encode(e) + } + } + { + if s.GameAccount.Set { + e.FieldStart("game_account") + s.GameAccount.Encode(e) + } + } + { + if s.GameLv.Set { + e.FieldStart("game_lv") + s.GameLv.Encode(e) + } + } } -var jsonFieldsNameOfUserCreate = [33]string{ +var jsonFieldsNameOfUserCreate = [46]string{ 0: "id", 1: "username", 2: "did", @@ -6105,6 +7070,19 @@ var jsonFieldsNameOfUserCreate = [33]string{ 30: "ten_at", 31: "next", 32: "room", + 33: "model", + 34: "model_at", + 35: "model_attack", + 36: "model_limit", + 37: "model_skill", + 38: "model_mode", + 39: "model_critical", + 40: "model_critical_d", + 41: "game", + 42: "game_test", + 43: "game_end", + 44: "game_account", + 45: "game_lv", } // Decode decodes UserCreate from json. @@ -6112,7 +7090,7 @@ func (s *UserCreate) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode UserCreate to nil") } - var requiredBitSet [5]uint8 + var requiredBitSet [6]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -6450,6 +7428,136 @@ func (s *UserCreate) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"room\"") } + case "model": + if err := func() error { + s.Model.Reset() + if err := s.Model.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model\"") + } + case "model_at": + if err := func() error { + s.ModelAt.Reset() + if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_at\"") + } + case "model_attack": + if err := func() error { + s.ModelAttack.Reset() + if err := s.ModelAttack.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_attack\"") + } + case "model_limit": + if err := func() error { + s.ModelLimit.Reset() + if err := s.ModelLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_limit\"") + } + case "model_skill": + if err := func() error { + s.ModelSkill.Reset() + if err := s.ModelSkill.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_skill\"") + } + case "model_mode": + if err := func() error { + s.ModelMode.Reset() + if err := s.ModelMode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_mode\"") + } + case "model_critical": + if err := func() error { + s.ModelCritical.Reset() + if err := s.ModelCritical.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical\"") + } + case "model_critical_d": + if err := func() error { + s.ModelCriticalD.Reset() + if err := s.ModelCriticalD.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical_d\"") + } + case "game": + if err := func() error { + s.Game.Reset() + if err := s.Game.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game\"") + } + case "game_test": + if err := func() error { + s.GameTest.Reset() + if err := s.GameTest.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_test\"") + } + case "game_end": + if err := func() error { + s.GameEnd.Reset() + if err := s.GameEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_end\"") + } + case "game_account": + if err := func() error { + s.GameAccount.Reset() + if err := s.GameAccount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_account\"") + } + case "game_lv": + if err := func() error { + s.GameLv.Reset() + if err := s.GameLv.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_lv\"") + } default: return d.Skip() } @@ -6459,12 +7567,13 @@ func (s *UserCreate) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [5]uint8{ + for i, mask := range [6]uint8{ 0b00000011, 0b00000000, 0b00000000, 0b00000000, 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -6715,9 +7824,87 @@ func (s *UserList) encodeFields(e *jx.Encoder) { s.Room.Encode(e) } } + { + if s.Model.Set { + e.FieldStart("model") + s.Model.Encode(e) + } + } + { + if s.ModelAt.Set { + e.FieldStart("model_at") + s.ModelAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.ModelAttack.Set { + e.FieldStart("model_attack") + s.ModelAttack.Encode(e) + } + } + { + if s.ModelLimit.Set { + e.FieldStart("model_limit") + s.ModelLimit.Encode(e) + } + } + { + if s.ModelSkill.Set { + e.FieldStart("model_skill") + s.ModelSkill.Encode(e) + } + } + { + if s.ModelMode.Set { + e.FieldStart("model_mode") + s.ModelMode.Encode(e) + } + } + { + if s.ModelCritical.Set { + e.FieldStart("model_critical") + s.ModelCritical.Encode(e) + } + } + { + if s.ModelCriticalD.Set { + e.FieldStart("model_critical_d") + s.ModelCriticalD.Encode(e) + } + } + { + if s.Game.Set { + e.FieldStart("game") + s.Game.Encode(e) + } + } + { + if s.GameTest.Set { + e.FieldStart("game_test") + s.GameTest.Encode(e) + } + } + { + if s.GameEnd.Set { + e.FieldStart("game_end") + s.GameEnd.Encode(e) + } + } + { + if s.GameAccount.Set { + e.FieldStart("game_account") + s.GameAccount.Encode(e) + } + } + { + if s.GameLv.Set { + e.FieldStart("game_lv") + s.GameLv.Encode(e) + } + } } -var jsonFieldsNameOfUserList = [33]string{ +var jsonFieldsNameOfUserList = [46]string{ 0: "id", 1: "username", 2: "did", @@ -6751,6 +7938,19 @@ var jsonFieldsNameOfUserList = [33]string{ 30: "ten_at", 31: "next", 32: "room", + 33: "model", + 34: "model_at", + 35: "model_attack", + 36: "model_limit", + 37: "model_skill", + 38: "model_mode", + 39: "model_critical", + 40: "model_critical_d", + 41: "game", + 42: "game_test", + 43: "game_end", + 44: "game_account", + 45: "game_lv", } // Decode decodes UserList from json. @@ -6758,7 +7958,7 @@ func (s *UserList) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode UserList to nil") } - var requiredBitSet [5]uint8 + var requiredBitSet [6]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -7096,6 +8296,136 @@ func (s *UserList) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"room\"") } + case "model": + if err := func() error { + s.Model.Reset() + if err := s.Model.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model\"") + } + case "model_at": + if err := func() error { + s.ModelAt.Reset() + if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_at\"") + } + case "model_attack": + if err := func() error { + s.ModelAttack.Reset() + if err := s.ModelAttack.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_attack\"") + } + case "model_limit": + if err := func() error { + s.ModelLimit.Reset() + if err := s.ModelLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_limit\"") + } + case "model_skill": + if err := func() error { + s.ModelSkill.Reset() + if err := s.ModelSkill.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_skill\"") + } + case "model_mode": + if err := func() error { + s.ModelMode.Reset() + if err := s.ModelMode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_mode\"") + } + case "model_critical": + if err := func() error { + s.ModelCritical.Reset() + if err := s.ModelCritical.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical\"") + } + case "model_critical_d": + if err := func() error { + s.ModelCriticalD.Reset() + if err := s.ModelCriticalD.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical_d\"") + } + case "game": + if err := func() error { + s.Game.Reset() + if err := s.Game.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game\"") + } + case "game_test": + if err := func() error { + s.GameTest.Reset() + if err := s.GameTest.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_test\"") + } + case "game_end": + if err := func() error { + s.GameEnd.Reset() + if err := s.GameEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_end\"") + } + case "game_account": + if err := func() error { + s.GameAccount.Reset() + if err := s.GameAccount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_account\"") + } + case "game_lv": + if err := func() error { + s.GameLv.Reset() + if err := s.GameLv.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_lv\"") + } default: return d.Skip() } @@ -7105,12 +8435,13 @@ func (s *UserList) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [5]uint8{ + for i, mask := range [6]uint8{ 0b00000011, 0b00000000, 0b00000000, 0b00000000, 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -7361,9 +8692,87 @@ func (s *UserRead) encodeFields(e *jx.Encoder) { s.Room.Encode(e) } } + { + if s.Model.Set { + e.FieldStart("model") + s.Model.Encode(e) + } + } + { + if s.ModelAt.Set { + e.FieldStart("model_at") + s.ModelAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.ModelAttack.Set { + e.FieldStart("model_attack") + s.ModelAttack.Encode(e) + } + } + { + if s.ModelLimit.Set { + e.FieldStart("model_limit") + s.ModelLimit.Encode(e) + } + } + { + if s.ModelSkill.Set { + e.FieldStart("model_skill") + s.ModelSkill.Encode(e) + } + } + { + if s.ModelMode.Set { + e.FieldStart("model_mode") + s.ModelMode.Encode(e) + } + } + { + if s.ModelCritical.Set { + e.FieldStart("model_critical") + s.ModelCritical.Encode(e) + } + } + { + if s.ModelCriticalD.Set { + e.FieldStart("model_critical_d") + s.ModelCriticalD.Encode(e) + } + } + { + if s.Game.Set { + e.FieldStart("game") + s.Game.Encode(e) + } + } + { + if s.GameTest.Set { + e.FieldStart("game_test") + s.GameTest.Encode(e) + } + } + { + if s.GameEnd.Set { + e.FieldStart("game_end") + s.GameEnd.Encode(e) + } + } + { + if s.GameAccount.Set { + e.FieldStart("game_account") + s.GameAccount.Encode(e) + } + } + { + if s.GameLv.Set { + e.FieldStart("game_lv") + s.GameLv.Encode(e) + } + } } -var jsonFieldsNameOfUserRead = [33]string{ +var jsonFieldsNameOfUserRead = [46]string{ 0: "id", 1: "username", 2: "did", @@ -7397,6 +8806,19 @@ var jsonFieldsNameOfUserRead = [33]string{ 30: "ten_at", 31: "next", 32: "room", + 33: "model", + 34: "model_at", + 35: "model_attack", + 36: "model_limit", + 37: "model_skill", + 38: "model_mode", + 39: "model_critical", + 40: "model_critical_d", + 41: "game", + 42: "game_test", + 43: "game_end", + 44: "game_account", + 45: "game_lv", } // Decode decodes UserRead from json. @@ -7404,7 +8826,7 @@ func (s *UserRead) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode UserRead to nil") } - var requiredBitSet [5]uint8 + var requiredBitSet [6]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -7742,6 +9164,136 @@ func (s *UserRead) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"room\"") } + case "model": + if err := func() error { + s.Model.Reset() + if err := s.Model.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model\"") + } + case "model_at": + if err := func() error { + s.ModelAt.Reset() + if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_at\"") + } + case "model_attack": + if err := func() error { + s.ModelAttack.Reset() + if err := s.ModelAttack.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_attack\"") + } + case "model_limit": + if err := func() error { + s.ModelLimit.Reset() + if err := s.ModelLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_limit\"") + } + case "model_skill": + if err := func() error { + s.ModelSkill.Reset() + if err := s.ModelSkill.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_skill\"") + } + case "model_mode": + if err := func() error { + s.ModelMode.Reset() + if err := s.ModelMode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_mode\"") + } + case "model_critical": + if err := func() error { + s.ModelCritical.Reset() + if err := s.ModelCritical.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical\"") + } + case "model_critical_d": + if err := func() error { + s.ModelCriticalD.Reset() + if err := s.ModelCriticalD.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical_d\"") + } + case "game": + if err := func() error { + s.Game.Reset() + if err := s.Game.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game\"") + } + case "game_test": + if err := func() error { + s.GameTest.Reset() + if err := s.GameTest.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_test\"") + } + case "game_end": + if err := func() error { + s.GameEnd.Reset() + if err := s.GameEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_end\"") + } + case "game_account": + if err := func() error { + s.GameAccount.Reset() + if err := s.GameAccount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_account\"") + } + case "game_lv": + if err := func() error { + s.GameLv.Reset() + if err := s.GameLv.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_lv\"") + } default: return d.Skip() } @@ -7751,12 +9303,13 @@ func (s *UserRead) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [5]uint8{ + for i, mask := range [6]uint8{ 0b00000011, 0b00000000, 0b00000000, 0b00000000, 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -8007,9 +9560,87 @@ func (s *UserUpdate) encodeFields(e *jx.Encoder) { s.Room.Encode(e) } } + { + if s.Model.Set { + e.FieldStart("model") + s.Model.Encode(e) + } + } + { + if s.ModelAt.Set { + e.FieldStart("model_at") + s.ModelAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.ModelAttack.Set { + e.FieldStart("model_attack") + s.ModelAttack.Encode(e) + } + } + { + if s.ModelLimit.Set { + e.FieldStart("model_limit") + s.ModelLimit.Encode(e) + } + } + { + if s.ModelSkill.Set { + e.FieldStart("model_skill") + s.ModelSkill.Encode(e) + } + } + { + if s.ModelMode.Set { + e.FieldStart("model_mode") + s.ModelMode.Encode(e) + } + } + { + if s.ModelCritical.Set { + e.FieldStart("model_critical") + s.ModelCritical.Encode(e) + } + } + { + if s.ModelCriticalD.Set { + e.FieldStart("model_critical_d") + s.ModelCriticalD.Encode(e) + } + } + { + if s.Game.Set { + e.FieldStart("game") + s.Game.Encode(e) + } + } + { + if s.GameTest.Set { + e.FieldStart("game_test") + s.GameTest.Encode(e) + } + } + { + if s.GameEnd.Set { + e.FieldStart("game_end") + s.GameEnd.Encode(e) + } + } + { + if s.GameAccount.Set { + e.FieldStart("game_account") + s.GameAccount.Encode(e) + } + } + { + if s.GameLv.Set { + e.FieldStart("game_lv") + s.GameLv.Encode(e) + } + } } -var jsonFieldsNameOfUserUpdate = [33]string{ +var jsonFieldsNameOfUserUpdate = [46]string{ 0: "id", 1: "username", 2: "did", @@ -8043,6 +9674,19 @@ var jsonFieldsNameOfUserUpdate = [33]string{ 30: "ten_at", 31: "next", 32: "room", + 33: "model", + 34: "model_at", + 35: "model_attack", + 36: "model_limit", + 37: "model_skill", + 38: "model_mode", + 39: "model_critical", + 40: "model_critical_d", + 41: "game", + 42: "game_test", + 43: "game_end", + 44: "game_account", + 45: "game_lv", } // Decode decodes UserUpdate from json. @@ -8050,7 +9694,7 @@ func (s *UserUpdate) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode UserUpdate to nil") } - var requiredBitSet [5]uint8 + var requiredBitSet [6]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -8388,6 +10032,136 @@ func (s *UserUpdate) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"room\"") } + case "model": + if err := func() error { + s.Model.Reset() + if err := s.Model.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model\"") + } + case "model_at": + if err := func() error { + s.ModelAt.Reset() + if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_at\"") + } + case "model_attack": + if err := func() error { + s.ModelAttack.Reset() + if err := s.ModelAttack.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_attack\"") + } + case "model_limit": + if err := func() error { + s.ModelLimit.Reset() + if err := s.ModelLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_limit\"") + } + case "model_skill": + if err := func() error { + s.ModelSkill.Reset() + if err := s.ModelSkill.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_skill\"") + } + case "model_mode": + if err := func() error { + s.ModelMode.Reset() + if err := s.ModelMode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_mode\"") + } + case "model_critical": + if err := func() error { + s.ModelCritical.Reset() + if err := s.ModelCritical.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical\"") + } + case "model_critical_d": + if err := func() error { + s.ModelCriticalD.Reset() + if err := s.ModelCriticalD.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"model_critical_d\"") + } + case "game": + if err := func() error { + s.Game.Reset() + if err := s.Game.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game\"") + } + case "game_test": + if err := func() error { + s.GameTest.Reset() + if err := s.GameTest.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_test\"") + } + case "game_end": + if err := func() error { + s.GameEnd.Reset() + if err := s.GameEnd.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_end\"") + } + case "game_account": + if err := func() error { + s.GameAccount.Reset() + if err := s.GameAccount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_account\"") + } + case "game_lv": + if err := func() error { + s.GameLv.Reset() + if err := s.GameLv.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"game_lv\"") + } default: return d.Skip() } @@ -8397,12 +10171,13 @@ func (s *UserUpdate) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [5]uint8{ + for i, mask := range [6]uint8{ 0b00000011, 0b00000000, 0b00000000, 0b00000000, 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. diff --git a/ent/ogent/oas_response_encoders_gen.go b/ent/ogent/oas_response_encoders_gen.go index 09de6c3..8d7c163 100644 --- a/ent/ogent/oas_response_encoders_gen.go +++ b/ent/ogent/oas_response_encoders_gen.go @@ -915,7 +915,7 @@ func encodeReadGroupResponse(response ReadGroupRes, w http.ResponseWriter, span } func encodeReadUserResponse(response ReadUserRes, w http.ResponseWriter, span trace.Span) error { - w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai") + w.Header().Set("Access-Control-Allow-Origin", "*") switch response := response.(type) { case *UserRead: w.Header().Set("Content-Type", "application/json") diff --git a/ent/ogent/oas_schemas_gen.go b/ent/ogent/oas_schemas_gen.go index a95d235..c5b81fb 100644 --- a/ent/ogent/oas_schemas_gen.go +++ b/ent/ogent/oas_schemas_gen.go @@ -218,39 +218,52 @@ func (s *CardList) SetCreatedAt(val OptDateTime) { // Ref: #/components/schemas/Card_OwnerRead type CardOwnerRead struct { - ID int `json:"id"` - Username string `json:"username"` - Did OptString `json:"did"` - Member OptBool `json:"member"` - Book OptBool `json:"book"` - Manga OptBool `json:"manga"` - Badge OptBool `json:"badge"` - Bsky OptBool `json:"bsky"` - Mastodon OptBool `json:"mastodon"` - Delete OptBool `json:"delete"` - Handle OptBool `json:"handle"` - CreatedAt OptDateTime `json:"created_at"` - UpdatedAt OptDateTime `json:"updated_at"` - RaidAt OptDateTime `json:"raid_at"` - ServerAt OptDateTime `json:"server_at"` - EggAt OptDateTime `json:"egg_at"` - Luck OptInt `json:"luck"` - LuckAt OptDateTime `json:"luck_at"` - Like OptInt `json:"like"` - LikeRank OptInt `json:"like_rank"` - LikeAt OptDateTime `json:"like_at"` - Fav OptInt `json:"fav"` - Ten OptBool `json:"ten"` - TenSu OptInt `json:"ten_su"` - TenKai OptInt `json:"ten_kai"` - Aiten OptInt `json:"aiten"` - TenCard OptString `json:"ten_card"` - TenDelete OptString `json:"ten_delete"` - TenPost OptString `json:"ten_post"` - TenGet OptString `json:"ten_get"` - TenAt OptDateTime `json:"ten_at"` - Next OptString `json:"next"` - Room OptInt `json:"room"` + ID int `json:"id"` + Username string `json:"username"` + Did OptString `json:"did"` + Member OptBool `json:"member"` + Book OptBool `json:"book"` + Manga OptBool `json:"manga"` + Badge OptBool `json:"badge"` + Bsky OptBool `json:"bsky"` + Mastodon OptBool `json:"mastodon"` + Delete OptBool `json:"delete"` + Handle OptBool `json:"handle"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + ServerAt OptDateTime `json:"server_at"` + EggAt OptDateTime `json:"egg_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + Fav OptInt `json:"fav"` + Ten OptBool `json:"ten"` + TenSu OptInt `json:"ten_su"` + TenKai OptInt `json:"ten_kai"` + Aiten OptInt `json:"aiten"` + TenCard OptString `json:"ten_card"` + TenDelete OptString `json:"ten_delete"` + TenPost OptString `json:"ten_post"` + TenGet OptString `json:"ten_get"` + TenAt OptDateTime `json:"ten_at"` + Next OptString `json:"next"` + Room OptInt `json:"room"` + Model OptBool `json:"model"` + ModelAt OptDateTime `json:"model_at"` + ModelAttack OptInt `json:"model_attack"` + ModelLimit OptInt `json:"model_limit"` + ModelSkill OptInt `json:"model_skill"` + ModelMode OptInt `json:"model_mode"` + ModelCritical OptInt `json:"model_critical"` + ModelCriticalD OptInt `json:"model_critical_d"` + Game OptBool `json:"game"` + GameTest OptBool `json:"game_test"` + GameEnd OptBool `json:"game_end"` + GameAccount OptBool `json:"game_account"` + GameLv OptInt `json:"game_lv"` } // GetID returns the value of ID. @@ -418,6 +431,71 @@ func (s *CardOwnerRead) GetRoom() OptInt { return s.Room } +// GetModel returns the value of Model. +func (s *CardOwnerRead) GetModel() OptBool { + return s.Model +} + +// GetModelAt returns the value of ModelAt. +func (s *CardOwnerRead) GetModelAt() OptDateTime { + return s.ModelAt +} + +// GetModelAttack returns the value of ModelAttack. +func (s *CardOwnerRead) GetModelAttack() OptInt { + return s.ModelAttack +} + +// GetModelLimit returns the value of ModelLimit. +func (s *CardOwnerRead) GetModelLimit() OptInt { + return s.ModelLimit +} + +// GetModelSkill returns the value of ModelSkill. +func (s *CardOwnerRead) GetModelSkill() OptInt { + return s.ModelSkill +} + +// GetModelMode returns the value of ModelMode. +func (s *CardOwnerRead) GetModelMode() OptInt { + return s.ModelMode +} + +// GetModelCritical returns the value of ModelCritical. +func (s *CardOwnerRead) GetModelCritical() OptInt { + return s.ModelCritical +} + +// GetModelCriticalD returns the value of ModelCriticalD. +func (s *CardOwnerRead) GetModelCriticalD() OptInt { + return s.ModelCriticalD +} + +// GetGame returns the value of Game. +func (s *CardOwnerRead) GetGame() OptBool { + return s.Game +} + +// GetGameTest returns the value of GameTest. +func (s *CardOwnerRead) GetGameTest() OptBool { + return s.GameTest +} + +// GetGameEnd returns the value of GameEnd. +func (s *CardOwnerRead) GetGameEnd() OptBool { + return s.GameEnd +} + +// GetGameAccount returns the value of GameAccount. +func (s *CardOwnerRead) GetGameAccount() OptBool { + return s.GameAccount +} + +// GetGameLv returns the value of GameLv. +func (s *CardOwnerRead) GetGameLv() OptInt { + return s.GameLv +} + // SetID sets the value of ID. func (s *CardOwnerRead) SetID(val int) { s.ID = val @@ -583,6 +661,71 @@ func (s *CardOwnerRead) SetRoom(val OptInt) { s.Room = val } +// SetModel sets the value of Model. +func (s *CardOwnerRead) SetModel(val OptBool) { + s.Model = val +} + +// SetModelAt sets the value of ModelAt. +func (s *CardOwnerRead) SetModelAt(val OptDateTime) { + s.ModelAt = val +} + +// SetModelAttack sets the value of ModelAttack. +func (s *CardOwnerRead) SetModelAttack(val OptInt) { + s.ModelAttack = val +} + +// SetModelLimit sets the value of ModelLimit. +func (s *CardOwnerRead) SetModelLimit(val OptInt) { + s.ModelLimit = val +} + +// SetModelSkill sets the value of ModelSkill. +func (s *CardOwnerRead) SetModelSkill(val OptInt) { + s.ModelSkill = val +} + +// SetModelMode sets the value of ModelMode. +func (s *CardOwnerRead) SetModelMode(val OptInt) { + s.ModelMode = val +} + +// SetModelCritical sets the value of ModelCritical. +func (s *CardOwnerRead) SetModelCritical(val OptInt) { + s.ModelCritical = val +} + +// SetModelCriticalD sets the value of ModelCriticalD. +func (s *CardOwnerRead) SetModelCriticalD(val OptInt) { + s.ModelCriticalD = val +} + +// SetGame sets the value of Game. +func (s *CardOwnerRead) SetGame(val OptBool) { + s.Game = val +} + +// SetGameTest sets the value of GameTest. +func (s *CardOwnerRead) SetGameTest(val OptBool) { + s.GameTest = val +} + +// SetGameEnd sets the value of GameEnd. +func (s *CardOwnerRead) SetGameEnd(val OptBool) { + s.GameEnd = val +} + +// SetGameAccount sets the value of GameAccount. +func (s *CardOwnerRead) SetGameAccount(val OptBool) { + s.GameAccount = val +} + +// SetGameLv sets the value of GameLv. +func (s *CardOwnerRead) SetGameLv(val OptInt) { + s.GameLv = val +} + func (*CardOwnerRead) readCardOwnerRes() {} // Ref: #/components/schemas/CardRead @@ -956,41 +1099,54 @@ func (s *CreateGroupReq) SetUsers(val []int) { } type CreateUserReq struct { - Username string `json:"username"` - Did OptString `json:"did"` - Member OptBool `json:"member"` - Book OptBool `json:"book"` - Manga OptBool `json:"manga"` - Badge OptBool `json:"badge"` - Bsky OptBool `json:"bsky"` - Mastodon OptBool `json:"mastodon"` - Delete OptBool `json:"delete"` - Handle OptBool `json:"handle"` - Token OptString `json:"token"` - Password string `json:"password"` - CreatedAt OptDateTime `json:"created_at"` - UpdatedAt OptDateTime `json:"updated_at"` - RaidAt OptDateTime `json:"raid_at"` - ServerAt OptDateTime `json:"server_at"` - EggAt OptDateTime `json:"egg_at"` - Luck OptInt `json:"luck"` - LuckAt OptDateTime `json:"luck_at"` - Like OptInt `json:"like"` - LikeRank OptInt `json:"like_rank"` - LikeAt OptDateTime `json:"like_at"` - Fav OptInt `json:"fav"` - Ten OptBool `json:"ten"` - TenSu OptInt `json:"ten_su"` - TenKai OptInt `json:"ten_kai"` - Aiten OptInt `json:"aiten"` - TenCard OptString `json:"ten_card"` - TenDelete OptString `json:"ten_delete"` - TenPost OptString `json:"ten_post"` - TenGet OptString `json:"ten_get"` - TenAt OptDateTime `json:"ten_at"` - Next OptString `json:"next"` - Room OptInt `json:"room"` - Card []int `json:"card"` + Username string `json:"username"` + Did OptString `json:"did"` + Member OptBool `json:"member"` + Book OptBool `json:"book"` + Manga OptBool `json:"manga"` + Badge OptBool `json:"badge"` + Bsky OptBool `json:"bsky"` + Mastodon OptBool `json:"mastodon"` + Delete OptBool `json:"delete"` + Handle OptBool `json:"handle"` + Token OptString `json:"token"` + Password string `json:"password"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + ServerAt OptDateTime `json:"server_at"` + EggAt OptDateTime `json:"egg_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + Fav OptInt `json:"fav"` + Ten OptBool `json:"ten"` + TenSu OptInt `json:"ten_su"` + TenKai OptInt `json:"ten_kai"` + Aiten OptInt `json:"aiten"` + TenCard OptString `json:"ten_card"` + TenDelete OptString `json:"ten_delete"` + TenPost OptString `json:"ten_post"` + TenGet OptString `json:"ten_get"` + TenAt OptDateTime `json:"ten_at"` + Next OptString `json:"next"` + Room OptInt `json:"room"` + Model OptBool `json:"model"` + ModelAt OptDateTime `json:"model_at"` + ModelAttack OptInt `json:"model_attack"` + ModelLimit OptInt `json:"model_limit"` + ModelSkill OptInt `json:"model_skill"` + ModelMode OptInt `json:"model_mode"` + ModelCritical OptInt `json:"model_critical"` + ModelCriticalD OptInt `json:"model_critical_d"` + Game OptBool `json:"game"` + GameTest OptBool `json:"game_test"` + GameEnd OptBool `json:"game_end"` + GameAccount OptBool `json:"game_account"` + GameLv OptInt `json:"game_lv"` + Card []int `json:"card"` } // GetUsername returns the value of Username. @@ -1163,6 +1319,71 @@ func (s *CreateUserReq) GetRoom() OptInt { return s.Room } +// GetModel returns the value of Model. +func (s *CreateUserReq) GetModel() OptBool { + return s.Model +} + +// GetModelAt returns the value of ModelAt. +func (s *CreateUserReq) GetModelAt() OptDateTime { + return s.ModelAt +} + +// GetModelAttack returns the value of ModelAttack. +func (s *CreateUserReq) GetModelAttack() OptInt { + return s.ModelAttack +} + +// GetModelLimit returns the value of ModelLimit. +func (s *CreateUserReq) GetModelLimit() OptInt { + return s.ModelLimit +} + +// GetModelSkill returns the value of ModelSkill. +func (s *CreateUserReq) GetModelSkill() OptInt { + return s.ModelSkill +} + +// GetModelMode returns the value of ModelMode. +func (s *CreateUserReq) GetModelMode() OptInt { + return s.ModelMode +} + +// GetModelCritical returns the value of ModelCritical. +func (s *CreateUserReq) GetModelCritical() OptInt { + return s.ModelCritical +} + +// GetModelCriticalD returns the value of ModelCriticalD. +func (s *CreateUserReq) GetModelCriticalD() OptInt { + return s.ModelCriticalD +} + +// GetGame returns the value of Game. +func (s *CreateUserReq) GetGame() OptBool { + return s.Game +} + +// GetGameTest returns the value of GameTest. +func (s *CreateUserReq) GetGameTest() OptBool { + return s.GameTest +} + +// GetGameEnd returns the value of GameEnd. +func (s *CreateUserReq) GetGameEnd() OptBool { + return s.GameEnd +} + +// GetGameAccount returns the value of GameAccount. +func (s *CreateUserReq) GetGameAccount() OptBool { + return s.GameAccount +} + +// GetGameLv returns the value of GameLv. +func (s *CreateUserReq) GetGameLv() OptInt { + return s.GameLv +} + // GetCard returns the value of Card. func (s *CreateUserReq) GetCard() []int { return s.Card @@ -1338,6 +1559,71 @@ func (s *CreateUserReq) SetRoom(val OptInt) { s.Room = val } +// SetModel sets the value of Model. +func (s *CreateUserReq) SetModel(val OptBool) { + s.Model = val +} + +// SetModelAt sets the value of ModelAt. +func (s *CreateUserReq) SetModelAt(val OptDateTime) { + s.ModelAt = val +} + +// SetModelAttack sets the value of ModelAttack. +func (s *CreateUserReq) SetModelAttack(val OptInt) { + s.ModelAttack = val +} + +// SetModelLimit sets the value of ModelLimit. +func (s *CreateUserReq) SetModelLimit(val OptInt) { + s.ModelLimit = val +} + +// SetModelSkill sets the value of ModelSkill. +func (s *CreateUserReq) SetModelSkill(val OptInt) { + s.ModelSkill = val +} + +// SetModelMode sets the value of ModelMode. +func (s *CreateUserReq) SetModelMode(val OptInt) { + s.ModelMode = val +} + +// SetModelCritical sets the value of ModelCritical. +func (s *CreateUserReq) SetModelCritical(val OptInt) { + s.ModelCritical = val +} + +// SetModelCriticalD sets the value of ModelCriticalD. +func (s *CreateUserReq) SetModelCriticalD(val OptInt) { + s.ModelCriticalD = val +} + +// SetGame sets the value of Game. +func (s *CreateUserReq) SetGame(val OptBool) { + s.Game = val +} + +// SetGameTest sets the value of GameTest. +func (s *CreateUserReq) SetGameTest(val OptBool) { + s.GameTest = val +} + +// SetGameEnd sets the value of GameEnd. +func (s *CreateUserReq) SetGameEnd(val OptBool) { + s.GameEnd = val +} + +// SetGameAccount sets the value of GameAccount. +func (s *CreateUserReq) SetGameAccount(val OptBool) { + s.GameAccount = val +} + +// SetGameLv sets the value of GameLv. +func (s *CreateUserReq) SetGameLv(val OptInt) { + s.GameLv = val +} + // SetCard sets the value of Card. func (s *CreateUserReq) SetCard(val []int) { s.Card = val @@ -1476,39 +1762,52 @@ func (*GroupUpdate) updateGroupRes() {} // Ref: #/components/schemas/Group_UsersList type GroupUsersList struct { - ID int `json:"id"` - Username string `json:"username"` - Did OptString `json:"did"` - Member OptBool `json:"member"` - Book OptBool `json:"book"` - Manga OptBool `json:"manga"` - Badge OptBool `json:"badge"` - Bsky OptBool `json:"bsky"` - Mastodon OptBool `json:"mastodon"` - Delete OptBool `json:"delete"` - Handle OptBool `json:"handle"` - CreatedAt OptDateTime `json:"created_at"` - UpdatedAt OptDateTime `json:"updated_at"` - RaidAt OptDateTime `json:"raid_at"` - ServerAt OptDateTime `json:"server_at"` - EggAt OptDateTime `json:"egg_at"` - Luck OptInt `json:"luck"` - LuckAt OptDateTime `json:"luck_at"` - Like OptInt `json:"like"` - LikeRank OptInt `json:"like_rank"` - LikeAt OptDateTime `json:"like_at"` - Fav OptInt `json:"fav"` - Ten OptBool `json:"ten"` - TenSu OptInt `json:"ten_su"` - TenKai OptInt `json:"ten_kai"` - Aiten OptInt `json:"aiten"` - TenCard OptString `json:"ten_card"` - TenDelete OptString `json:"ten_delete"` - TenPost OptString `json:"ten_post"` - TenGet OptString `json:"ten_get"` - TenAt OptDateTime `json:"ten_at"` - Next OptString `json:"next"` - Room OptInt `json:"room"` + ID int `json:"id"` + Username string `json:"username"` + Did OptString `json:"did"` + Member OptBool `json:"member"` + Book OptBool `json:"book"` + Manga OptBool `json:"manga"` + Badge OptBool `json:"badge"` + Bsky OptBool `json:"bsky"` + Mastodon OptBool `json:"mastodon"` + Delete OptBool `json:"delete"` + Handle OptBool `json:"handle"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + ServerAt OptDateTime `json:"server_at"` + EggAt OptDateTime `json:"egg_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + Fav OptInt `json:"fav"` + Ten OptBool `json:"ten"` + TenSu OptInt `json:"ten_su"` + TenKai OptInt `json:"ten_kai"` + Aiten OptInt `json:"aiten"` + TenCard OptString `json:"ten_card"` + TenDelete OptString `json:"ten_delete"` + TenPost OptString `json:"ten_post"` + TenGet OptString `json:"ten_get"` + TenAt OptDateTime `json:"ten_at"` + Next OptString `json:"next"` + Room OptInt `json:"room"` + Model OptBool `json:"model"` + ModelAt OptDateTime `json:"model_at"` + ModelAttack OptInt `json:"model_attack"` + ModelLimit OptInt `json:"model_limit"` + ModelSkill OptInt `json:"model_skill"` + ModelMode OptInt `json:"model_mode"` + ModelCritical OptInt `json:"model_critical"` + ModelCriticalD OptInt `json:"model_critical_d"` + Game OptBool `json:"game"` + GameTest OptBool `json:"game_test"` + GameEnd OptBool `json:"game_end"` + GameAccount OptBool `json:"game_account"` + GameLv OptInt `json:"game_lv"` } // GetID returns the value of ID. @@ -1676,6 +1975,71 @@ func (s *GroupUsersList) GetRoom() OptInt { return s.Room } +// GetModel returns the value of Model. +func (s *GroupUsersList) GetModel() OptBool { + return s.Model +} + +// GetModelAt returns the value of ModelAt. +func (s *GroupUsersList) GetModelAt() OptDateTime { + return s.ModelAt +} + +// GetModelAttack returns the value of ModelAttack. +func (s *GroupUsersList) GetModelAttack() OptInt { + return s.ModelAttack +} + +// GetModelLimit returns the value of ModelLimit. +func (s *GroupUsersList) GetModelLimit() OptInt { + return s.ModelLimit +} + +// GetModelSkill returns the value of ModelSkill. +func (s *GroupUsersList) GetModelSkill() OptInt { + return s.ModelSkill +} + +// GetModelMode returns the value of ModelMode. +func (s *GroupUsersList) GetModelMode() OptInt { + return s.ModelMode +} + +// GetModelCritical returns the value of ModelCritical. +func (s *GroupUsersList) GetModelCritical() OptInt { + return s.ModelCritical +} + +// GetModelCriticalD returns the value of ModelCriticalD. +func (s *GroupUsersList) GetModelCriticalD() OptInt { + return s.ModelCriticalD +} + +// GetGame returns the value of Game. +func (s *GroupUsersList) GetGame() OptBool { + return s.Game +} + +// GetGameTest returns the value of GameTest. +func (s *GroupUsersList) GetGameTest() OptBool { + return s.GameTest +} + +// GetGameEnd returns the value of GameEnd. +func (s *GroupUsersList) GetGameEnd() OptBool { + return s.GameEnd +} + +// GetGameAccount returns the value of GameAccount. +func (s *GroupUsersList) GetGameAccount() OptBool { + return s.GameAccount +} + +// GetGameLv returns the value of GameLv. +func (s *GroupUsersList) GetGameLv() OptInt { + return s.GameLv +} + // SetID sets the value of ID. func (s *GroupUsersList) SetID(val int) { s.ID = val @@ -1841,6 +2205,71 @@ func (s *GroupUsersList) SetRoom(val OptInt) { s.Room = val } +// SetModel sets the value of Model. +func (s *GroupUsersList) SetModel(val OptBool) { + s.Model = val +} + +// SetModelAt sets the value of ModelAt. +func (s *GroupUsersList) SetModelAt(val OptDateTime) { + s.ModelAt = val +} + +// SetModelAttack sets the value of ModelAttack. +func (s *GroupUsersList) SetModelAttack(val OptInt) { + s.ModelAttack = val +} + +// SetModelLimit sets the value of ModelLimit. +func (s *GroupUsersList) SetModelLimit(val OptInt) { + s.ModelLimit = val +} + +// SetModelSkill sets the value of ModelSkill. +func (s *GroupUsersList) SetModelSkill(val OptInt) { + s.ModelSkill = val +} + +// SetModelMode sets the value of ModelMode. +func (s *GroupUsersList) SetModelMode(val OptInt) { + s.ModelMode = val +} + +// SetModelCritical sets the value of ModelCritical. +func (s *GroupUsersList) SetModelCritical(val OptInt) { + s.ModelCritical = val +} + +// SetModelCriticalD sets the value of ModelCriticalD. +func (s *GroupUsersList) SetModelCriticalD(val OptInt) { + s.ModelCriticalD = val +} + +// SetGame sets the value of Game. +func (s *GroupUsersList) SetGame(val OptBool) { + s.Game = val +} + +// SetGameTest sets the value of GameTest. +func (s *GroupUsersList) SetGameTest(val OptBool) { + s.GameTest = val +} + +// SetGameEnd sets the value of GameEnd. +func (s *GroupUsersList) SetGameEnd(val OptBool) { + s.GameEnd = val +} + +// SetGameAccount sets the value of GameAccount. +func (s *GroupUsersList) SetGameAccount(val OptBool) { + s.GameAccount = val +} + +// SetGameLv sets the value of GameLv. +func (s *GroupUsersList) SetGameLv(val OptInt) { + s.GameLv = val +} + type ListCardOKApplicationJSON []CardList func (*ListCardOKApplicationJSON) listCardRes() {} @@ -2390,38 +2819,51 @@ func (s *UpdateGroupReq) SetUsers(val []int) { } type UpdateUserReq struct { - Did OptString `json:"did"` - Member OptBool `json:"member"` - Book OptBool `json:"book"` - Manga OptBool `json:"manga"` - Badge OptBool `json:"badge"` - Bsky OptBool `json:"bsky"` - Mastodon OptBool `json:"mastodon"` - Delete OptBool `json:"delete"` - Handle OptBool `json:"handle"` - Token OptString `json:"token"` - UpdatedAt OptDateTime `json:"updated_at"` - RaidAt OptDateTime `json:"raid_at"` - ServerAt OptDateTime `json:"server_at"` - EggAt OptDateTime `json:"egg_at"` - Luck OptInt `json:"luck"` - LuckAt OptDateTime `json:"luck_at"` - Like OptInt `json:"like"` - LikeRank OptInt `json:"like_rank"` - LikeAt OptDateTime `json:"like_at"` - Fav OptInt `json:"fav"` - Ten OptBool `json:"ten"` - TenSu OptInt `json:"ten_su"` - TenKai OptInt `json:"ten_kai"` - Aiten OptInt `json:"aiten"` - TenCard OptString `json:"ten_card"` - TenDelete OptString `json:"ten_delete"` - TenPost OptString `json:"ten_post"` - TenGet OptString `json:"ten_get"` - TenAt OptDateTime `json:"ten_at"` - Next OptString `json:"next"` - Room OptInt `json:"room"` - Card []int `json:"card"` + Did OptString `json:"did"` + Member OptBool `json:"member"` + Book OptBool `json:"book"` + Manga OptBool `json:"manga"` + Badge OptBool `json:"badge"` + Bsky OptBool `json:"bsky"` + Mastodon OptBool `json:"mastodon"` + Delete OptBool `json:"delete"` + Handle OptBool `json:"handle"` + Token OptString `json:"token"` + UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + ServerAt OptDateTime `json:"server_at"` + EggAt OptDateTime `json:"egg_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + Fav OptInt `json:"fav"` + Ten OptBool `json:"ten"` + TenSu OptInt `json:"ten_su"` + TenKai OptInt `json:"ten_kai"` + Aiten OptInt `json:"aiten"` + TenCard OptString `json:"ten_card"` + TenDelete OptString `json:"ten_delete"` + TenPost OptString `json:"ten_post"` + TenGet OptString `json:"ten_get"` + TenAt OptDateTime `json:"ten_at"` + Next OptString `json:"next"` + Room OptInt `json:"room"` + Model OptBool `json:"model"` + ModelAt OptDateTime `json:"model_at"` + ModelAttack OptInt `json:"model_attack"` + ModelLimit OptInt `json:"model_limit"` + ModelSkill OptInt `json:"model_skill"` + ModelMode OptInt `json:"model_mode"` + ModelCritical OptInt `json:"model_critical"` + ModelCriticalD OptInt `json:"model_critical_d"` + Game OptBool `json:"game"` + GameTest OptBool `json:"game_test"` + GameEnd OptBool `json:"game_end"` + GameAccount OptBool `json:"game_account"` + GameLv OptInt `json:"game_lv"` + Card []int `json:"card"` } // GetDid returns the value of Did. @@ -2579,6 +3021,71 @@ func (s *UpdateUserReq) GetRoom() OptInt { return s.Room } +// GetModel returns the value of Model. +func (s *UpdateUserReq) GetModel() OptBool { + return s.Model +} + +// GetModelAt returns the value of ModelAt. +func (s *UpdateUserReq) GetModelAt() OptDateTime { + return s.ModelAt +} + +// GetModelAttack returns the value of ModelAttack. +func (s *UpdateUserReq) GetModelAttack() OptInt { + return s.ModelAttack +} + +// GetModelLimit returns the value of ModelLimit. +func (s *UpdateUserReq) GetModelLimit() OptInt { + return s.ModelLimit +} + +// GetModelSkill returns the value of ModelSkill. +func (s *UpdateUserReq) GetModelSkill() OptInt { + return s.ModelSkill +} + +// GetModelMode returns the value of ModelMode. +func (s *UpdateUserReq) GetModelMode() OptInt { + return s.ModelMode +} + +// GetModelCritical returns the value of ModelCritical. +func (s *UpdateUserReq) GetModelCritical() OptInt { + return s.ModelCritical +} + +// GetModelCriticalD returns the value of ModelCriticalD. +func (s *UpdateUserReq) GetModelCriticalD() OptInt { + return s.ModelCriticalD +} + +// GetGame returns the value of Game. +func (s *UpdateUserReq) GetGame() OptBool { + return s.Game +} + +// GetGameTest returns the value of GameTest. +func (s *UpdateUserReq) GetGameTest() OptBool { + return s.GameTest +} + +// GetGameEnd returns the value of GameEnd. +func (s *UpdateUserReq) GetGameEnd() OptBool { + return s.GameEnd +} + +// GetGameAccount returns the value of GameAccount. +func (s *UpdateUserReq) GetGameAccount() OptBool { + return s.GameAccount +} + +// GetGameLv returns the value of GameLv. +func (s *UpdateUserReq) GetGameLv() OptInt { + return s.GameLv +} + // GetCard returns the value of Card. func (s *UpdateUserReq) GetCard() []int { return s.Card @@ -2739,6 +3246,71 @@ func (s *UpdateUserReq) SetRoom(val OptInt) { s.Room = val } +// SetModel sets the value of Model. +func (s *UpdateUserReq) SetModel(val OptBool) { + s.Model = val +} + +// SetModelAt sets the value of ModelAt. +func (s *UpdateUserReq) SetModelAt(val OptDateTime) { + s.ModelAt = val +} + +// SetModelAttack sets the value of ModelAttack. +func (s *UpdateUserReq) SetModelAttack(val OptInt) { + s.ModelAttack = val +} + +// SetModelLimit sets the value of ModelLimit. +func (s *UpdateUserReq) SetModelLimit(val OptInt) { + s.ModelLimit = val +} + +// SetModelSkill sets the value of ModelSkill. +func (s *UpdateUserReq) SetModelSkill(val OptInt) { + s.ModelSkill = val +} + +// SetModelMode sets the value of ModelMode. +func (s *UpdateUserReq) SetModelMode(val OptInt) { + s.ModelMode = val +} + +// SetModelCritical sets the value of ModelCritical. +func (s *UpdateUserReq) SetModelCritical(val OptInt) { + s.ModelCritical = val +} + +// SetModelCriticalD sets the value of ModelCriticalD. +func (s *UpdateUserReq) SetModelCriticalD(val OptInt) { + s.ModelCriticalD = val +} + +// SetGame sets the value of Game. +func (s *UpdateUserReq) SetGame(val OptBool) { + s.Game = val +} + +// SetGameTest sets the value of GameTest. +func (s *UpdateUserReq) SetGameTest(val OptBool) { + s.GameTest = val +} + +// SetGameEnd sets the value of GameEnd. +func (s *UpdateUserReq) SetGameEnd(val OptBool) { + s.GameEnd = val +} + +// SetGameAccount sets the value of GameAccount. +func (s *UpdateUserReq) SetGameAccount(val OptBool) { + s.GameAccount = val +} + +// SetGameLv sets the value of GameLv. +func (s *UpdateUserReq) SetGameLv(val OptInt) { + s.GameLv = val +} + // SetCard sets the value of Card. func (s *UpdateUserReq) SetCard(val []int) { s.Card = val @@ -2849,39 +3421,52 @@ func (s *UserCardList) SetCreatedAt(val OptDateTime) { // Ref: #/components/schemas/UserCreate type UserCreate struct { - ID int `json:"id"` - Username string `json:"username"` - Did OptString `json:"did"` - Member OptBool `json:"member"` - Book OptBool `json:"book"` - Manga OptBool `json:"manga"` - Badge OptBool `json:"badge"` - Bsky OptBool `json:"bsky"` - Mastodon OptBool `json:"mastodon"` - Delete OptBool `json:"delete"` - Handle OptBool `json:"handle"` - CreatedAt OptDateTime `json:"created_at"` - UpdatedAt OptDateTime `json:"updated_at"` - RaidAt OptDateTime `json:"raid_at"` - ServerAt OptDateTime `json:"server_at"` - EggAt OptDateTime `json:"egg_at"` - Luck OptInt `json:"luck"` - LuckAt OptDateTime `json:"luck_at"` - Like OptInt `json:"like"` - LikeRank OptInt `json:"like_rank"` - LikeAt OptDateTime `json:"like_at"` - Fav OptInt `json:"fav"` - Ten OptBool `json:"ten"` - TenSu OptInt `json:"ten_su"` - TenKai OptInt `json:"ten_kai"` - Aiten OptInt `json:"aiten"` - TenCard OptString `json:"ten_card"` - TenDelete OptString `json:"ten_delete"` - TenPost OptString `json:"ten_post"` - TenGet OptString `json:"ten_get"` - TenAt OptDateTime `json:"ten_at"` - Next OptString `json:"next"` - Room OptInt `json:"room"` + ID int `json:"id"` + Username string `json:"username"` + Did OptString `json:"did"` + Member OptBool `json:"member"` + Book OptBool `json:"book"` + Manga OptBool `json:"manga"` + Badge OptBool `json:"badge"` + Bsky OptBool `json:"bsky"` + Mastodon OptBool `json:"mastodon"` + Delete OptBool `json:"delete"` + Handle OptBool `json:"handle"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + ServerAt OptDateTime `json:"server_at"` + EggAt OptDateTime `json:"egg_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + Fav OptInt `json:"fav"` + Ten OptBool `json:"ten"` + TenSu OptInt `json:"ten_su"` + TenKai OptInt `json:"ten_kai"` + Aiten OptInt `json:"aiten"` + TenCard OptString `json:"ten_card"` + TenDelete OptString `json:"ten_delete"` + TenPost OptString `json:"ten_post"` + TenGet OptString `json:"ten_get"` + TenAt OptDateTime `json:"ten_at"` + Next OptString `json:"next"` + Room OptInt `json:"room"` + Model OptBool `json:"model"` + ModelAt OptDateTime `json:"model_at"` + ModelAttack OptInt `json:"model_attack"` + ModelLimit OptInt `json:"model_limit"` + ModelSkill OptInt `json:"model_skill"` + ModelMode OptInt `json:"model_mode"` + ModelCritical OptInt `json:"model_critical"` + ModelCriticalD OptInt `json:"model_critical_d"` + Game OptBool `json:"game"` + GameTest OptBool `json:"game_test"` + GameEnd OptBool `json:"game_end"` + GameAccount OptBool `json:"game_account"` + GameLv OptInt `json:"game_lv"` } // GetID returns the value of ID. @@ -3049,6 +3634,71 @@ func (s *UserCreate) GetRoom() OptInt { return s.Room } +// GetModel returns the value of Model. +func (s *UserCreate) GetModel() OptBool { + return s.Model +} + +// GetModelAt returns the value of ModelAt. +func (s *UserCreate) GetModelAt() OptDateTime { + return s.ModelAt +} + +// GetModelAttack returns the value of ModelAttack. +func (s *UserCreate) GetModelAttack() OptInt { + return s.ModelAttack +} + +// GetModelLimit returns the value of ModelLimit. +func (s *UserCreate) GetModelLimit() OptInt { + return s.ModelLimit +} + +// GetModelSkill returns the value of ModelSkill. +func (s *UserCreate) GetModelSkill() OptInt { + return s.ModelSkill +} + +// GetModelMode returns the value of ModelMode. +func (s *UserCreate) GetModelMode() OptInt { + return s.ModelMode +} + +// GetModelCritical returns the value of ModelCritical. +func (s *UserCreate) GetModelCritical() OptInt { + return s.ModelCritical +} + +// GetModelCriticalD returns the value of ModelCriticalD. +func (s *UserCreate) GetModelCriticalD() OptInt { + return s.ModelCriticalD +} + +// GetGame returns the value of Game. +func (s *UserCreate) GetGame() OptBool { + return s.Game +} + +// GetGameTest returns the value of GameTest. +func (s *UserCreate) GetGameTest() OptBool { + return s.GameTest +} + +// GetGameEnd returns the value of GameEnd. +func (s *UserCreate) GetGameEnd() OptBool { + return s.GameEnd +} + +// GetGameAccount returns the value of GameAccount. +func (s *UserCreate) GetGameAccount() OptBool { + return s.GameAccount +} + +// GetGameLv returns the value of GameLv. +func (s *UserCreate) GetGameLv() OptInt { + return s.GameLv +} + // SetID sets the value of ID. func (s *UserCreate) SetID(val int) { s.ID = val @@ -3214,43 +3864,121 @@ func (s *UserCreate) SetRoom(val OptInt) { s.Room = val } +// SetModel sets the value of Model. +func (s *UserCreate) SetModel(val OptBool) { + s.Model = val +} + +// SetModelAt sets the value of ModelAt. +func (s *UserCreate) SetModelAt(val OptDateTime) { + s.ModelAt = val +} + +// SetModelAttack sets the value of ModelAttack. +func (s *UserCreate) SetModelAttack(val OptInt) { + s.ModelAttack = val +} + +// SetModelLimit sets the value of ModelLimit. +func (s *UserCreate) SetModelLimit(val OptInt) { + s.ModelLimit = val +} + +// SetModelSkill sets the value of ModelSkill. +func (s *UserCreate) SetModelSkill(val OptInt) { + s.ModelSkill = val +} + +// SetModelMode sets the value of ModelMode. +func (s *UserCreate) SetModelMode(val OptInt) { + s.ModelMode = val +} + +// SetModelCritical sets the value of ModelCritical. +func (s *UserCreate) SetModelCritical(val OptInt) { + s.ModelCritical = val +} + +// SetModelCriticalD sets the value of ModelCriticalD. +func (s *UserCreate) SetModelCriticalD(val OptInt) { + s.ModelCriticalD = val +} + +// SetGame sets the value of Game. +func (s *UserCreate) SetGame(val OptBool) { + s.Game = val +} + +// SetGameTest sets the value of GameTest. +func (s *UserCreate) SetGameTest(val OptBool) { + s.GameTest = val +} + +// SetGameEnd sets the value of GameEnd. +func (s *UserCreate) SetGameEnd(val OptBool) { + s.GameEnd = val +} + +// SetGameAccount sets the value of GameAccount. +func (s *UserCreate) SetGameAccount(val OptBool) { + s.GameAccount = val +} + +// SetGameLv sets the value of GameLv. +func (s *UserCreate) SetGameLv(val OptInt) { + s.GameLv = val +} + func (*UserCreate) createUserRes() {} // Ref: #/components/schemas/UserList type UserList struct { - ID int `json:"id"` - Username string `json:"username"` - Did OptString `json:"did"` - Member OptBool `json:"member"` - Book OptBool `json:"book"` - Manga OptBool `json:"manga"` - Badge OptBool `json:"badge"` - Bsky OptBool `json:"bsky"` - Mastodon OptBool `json:"mastodon"` - Delete OptBool `json:"delete"` - Handle OptBool `json:"handle"` - CreatedAt OptDateTime `json:"created_at"` - UpdatedAt OptDateTime `json:"updated_at"` - RaidAt OptDateTime `json:"raid_at"` - ServerAt OptDateTime `json:"server_at"` - EggAt OptDateTime `json:"egg_at"` - Luck OptInt `json:"luck"` - LuckAt OptDateTime `json:"luck_at"` - Like OptInt `json:"like"` - LikeRank OptInt `json:"like_rank"` - LikeAt OptDateTime `json:"like_at"` - Fav OptInt `json:"fav"` - Ten OptBool `json:"ten"` - TenSu OptInt `json:"ten_su"` - TenKai OptInt `json:"ten_kai"` - Aiten OptInt `json:"aiten"` - TenCard OptString `json:"ten_card"` - TenDelete OptString `json:"ten_delete"` - TenPost OptString `json:"ten_post"` - TenGet OptString `json:"ten_get"` - TenAt OptDateTime `json:"ten_at"` - Next OptString `json:"next"` - Room OptInt `json:"room"` + ID int `json:"id"` + Username string `json:"username"` + Did OptString `json:"did"` + Member OptBool `json:"member"` + Book OptBool `json:"book"` + Manga OptBool `json:"manga"` + Badge OptBool `json:"badge"` + Bsky OptBool `json:"bsky"` + Mastodon OptBool `json:"mastodon"` + Delete OptBool `json:"delete"` + Handle OptBool `json:"handle"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + ServerAt OptDateTime `json:"server_at"` + EggAt OptDateTime `json:"egg_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + Fav OptInt `json:"fav"` + Ten OptBool `json:"ten"` + TenSu OptInt `json:"ten_su"` + TenKai OptInt `json:"ten_kai"` + Aiten OptInt `json:"aiten"` + TenCard OptString `json:"ten_card"` + TenDelete OptString `json:"ten_delete"` + TenPost OptString `json:"ten_post"` + TenGet OptString `json:"ten_get"` + TenAt OptDateTime `json:"ten_at"` + Next OptString `json:"next"` + Room OptInt `json:"room"` + Model OptBool `json:"model"` + ModelAt OptDateTime `json:"model_at"` + ModelAttack OptInt `json:"model_attack"` + ModelLimit OptInt `json:"model_limit"` + ModelSkill OptInt `json:"model_skill"` + ModelMode OptInt `json:"model_mode"` + ModelCritical OptInt `json:"model_critical"` + ModelCriticalD OptInt `json:"model_critical_d"` + Game OptBool `json:"game"` + GameTest OptBool `json:"game_test"` + GameEnd OptBool `json:"game_end"` + GameAccount OptBool `json:"game_account"` + GameLv OptInt `json:"game_lv"` } // GetID returns the value of ID. @@ -3418,6 +4146,71 @@ func (s *UserList) GetRoom() OptInt { return s.Room } +// GetModel returns the value of Model. +func (s *UserList) GetModel() OptBool { + return s.Model +} + +// GetModelAt returns the value of ModelAt. +func (s *UserList) GetModelAt() OptDateTime { + return s.ModelAt +} + +// GetModelAttack returns the value of ModelAttack. +func (s *UserList) GetModelAttack() OptInt { + return s.ModelAttack +} + +// GetModelLimit returns the value of ModelLimit. +func (s *UserList) GetModelLimit() OptInt { + return s.ModelLimit +} + +// GetModelSkill returns the value of ModelSkill. +func (s *UserList) GetModelSkill() OptInt { + return s.ModelSkill +} + +// GetModelMode returns the value of ModelMode. +func (s *UserList) GetModelMode() OptInt { + return s.ModelMode +} + +// GetModelCritical returns the value of ModelCritical. +func (s *UserList) GetModelCritical() OptInt { + return s.ModelCritical +} + +// GetModelCriticalD returns the value of ModelCriticalD. +func (s *UserList) GetModelCriticalD() OptInt { + return s.ModelCriticalD +} + +// GetGame returns the value of Game. +func (s *UserList) GetGame() OptBool { + return s.Game +} + +// GetGameTest returns the value of GameTest. +func (s *UserList) GetGameTest() OptBool { + return s.GameTest +} + +// GetGameEnd returns the value of GameEnd. +func (s *UserList) GetGameEnd() OptBool { + return s.GameEnd +} + +// GetGameAccount returns the value of GameAccount. +func (s *UserList) GetGameAccount() OptBool { + return s.GameAccount +} + +// GetGameLv returns the value of GameLv. +func (s *UserList) GetGameLv() OptInt { + return s.GameLv +} + // SetID sets the value of ID. func (s *UserList) SetID(val int) { s.ID = val @@ -3583,41 +4376,119 @@ func (s *UserList) SetRoom(val OptInt) { s.Room = val } +// SetModel sets the value of Model. +func (s *UserList) SetModel(val OptBool) { + s.Model = val +} + +// SetModelAt sets the value of ModelAt. +func (s *UserList) SetModelAt(val OptDateTime) { + s.ModelAt = val +} + +// SetModelAttack sets the value of ModelAttack. +func (s *UserList) SetModelAttack(val OptInt) { + s.ModelAttack = val +} + +// SetModelLimit sets the value of ModelLimit. +func (s *UserList) SetModelLimit(val OptInt) { + s.ModelLimit = val +} + +// SetModelSkill sets the value of ModelSkill. +func (s *UserList) SetModelSkill(val OptInt) { + s.ModelSkill = val +} + +// SetModelMode sets the value of ModelMode. +func (s *UserList) SetModelMode(val OptInt) { + s.ModelMode = val +} + +// SetModelCritical sets the value of ModelCritical. +func (s *UserList) SetModelCritical(val OptInt) { + s.ModelCritical = val +} + +// SetModelCriticalD sets the value of ModelCriticalD. +func (s *UserList) SetModelCriticalD(val OptInt) { + s.ModelCriticalD = val +} + +// SetGame sets the value of Game. +func (s *UserList) SetGame(val OptBool) { + s.Game = val +} + +// SetGameTest sets the value of GameTest. +func (s *UserList) SetGameTest(val OptBool) { + s.GameTest = val +} + +// SetGameEnd sets the value of GameEnd. +func (s *UserList) SetGameEnd(val OptBool) { + s.GameEnd = val +} + +// SetGameAccount sets the value of GameAccount. +func (s *UserList) SetGameAccount(val OptBool) { + s.GameAccount = val +} + +// SetGameLv sets the value of GameLv. +func (s *UserList) SetGameLv(val OptInt) { + s.GameLv = val +} + // Ref: #/components/schemas/UserRead type UserRead struct { - ID int `json:"id"` - Username string `json:"username"` - Did OptString `json:"did"` - Member OptBool `json:"member"` - Book OptBool `json:"book"` - Manga OptBool `json:"manga"` - Badge OptBool `json:"badge"` - Bsky OptBool `json:"bsky"` - Mastodon OptBool `json:"mastodon"` - Delete OptBool `json:"delete"` - Handle OptBool `json:"handle"` - CreatedAt OptDateTime `json:"created_at"` - UpdatedAt OptDateTime `json:"updated_at"` - RaidAt OptDateTime `json:"raid_at"` - ServerAt OptDateTime `json:"server_at"` - EggAt OptDateTime `json:"egg_at"` - Luck OptInt `json:"luck"` - LuckAt OptDateTime `json:"luck_at"` - Like OptInt `json:"like"` - LikeRank OptInt `json:"like_rank"` - LikeAt OptDateTime `json:"like_at"` - Fav OptInt `json:"fav"` - Ten OptBool `json:"ten"` - TenSu OptInt `json:"ten_su"` - TenKai OptInt `json:"ten_kai"` - Aiten OptInt `json:"aiten"` - TenCard OptString `json:"ten_card"` - TenDelete OptString `json:"ten_delete"` - TenPost OptString `json:"ten_post"` - TenGet OptString `json:"ten_get"` - TenAt OptDateTime `json:"ten_at"` - Next OptString `json:"next"` - Room OptInt `json:"room"` + ID int `json:"id"` + Username string `json:"username"` + Did OptString `json:"did"` + Member OptBool `json:"member"` + Book OptBool `json:"book"` + Manga OptBool `json:"manga"` + Badge OptBool `json:"badge"` + Bsky OptBool `json:"bsky"` + Mastodon OptBool `json:"mastodon"` + Delete OptBool `json:"delete"` + Handle OptBool `json:"handle"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + ServerAt OptDateTime `json:"server_at"` + EggAt OptDateTime `json:"egg_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + Fav OptInt `json:"fav"` + Ten OptBool `json:"ten"` + TenSu OptInt `json:"ten_su"` + TenKai OptInt `json:"ten_kai"` + Aiten OptInt `json:"aiten"` + TenCard OptString `json:"ten_card"` + TenDelete OptString `json:"ten_delete"` + TenPost OptString `json:"ten_post"` + TenGet OptString `json:"ten_get"` + TenAt OptDateTime `json:"ten_at"` + Next OptString `json:"next"` + Room OptInt `json:"room"` + Model OptBool `json:"model"` + ModelAt OptDateTime `json:"model_at"` + ModelAttack OptInt `json:"model_attack"` + ModelLimit OptInt `json:"model_limit"` + ModelSkill OptInt `json:"model_skill"` + ModelMode OptInt `json:"model_mode"` + ModelCritical OptInt `json:"model_critical"` + ModelCriticalD OptInt `json:"model_critical_d"` + Game OptBool `json:"game"` + GameTest OptBool `json:"game_test"` + GameEnd OptBool `json:"game_end"` + GameAccount OptBool `json:"game_account"` + GameLv OptInt `json:"game_lv"` } // GetID returns the value of ID. @@ -3785,6 +4656,71 @@ func (s *UserRead) GetRoom() OptInt { return s.Room } +// GetModel returns the value of Model. +func (s *UserRead) GetModel() OptBool { + return s.Model +} + +// GetModelAt returns the value of ModelAt. +func (s *UserRead) GetModelAt() OptDateTime { + return s.ModelAt +} + +// GetModelAttack returns the value of ModelAttack. +func (s *UserRead) GetModelAttack() OptInt { + return s.ModelAttack +} + +// GetModelLimit returns the value of ModelLimit. +func (s *UserRead) GetModelLimit() OptInt { + return s.ModelLimit +} + +// GetModelSkill returns the value of ModelSkill. +func (s *UserRead) GetModelSkill() OptInt { + return s.ModelSkill +} + +// GetModelMode returns the value of ModelMode. +func (s *UserRead) GetModelMode() OptInt { + return s.ModelMode +} + +// GetModelCritical returns the value of ModelCritical. +func (s *UserRead) GetModelCritical() OptInt { + return s.ModelCritical +} + +// GetModelCriticalD returns the value of ModelCriticalD. +func (s *UserRead) GetModelCriticalD() OptInt { + return s.ModelCriticalD +} + +// GetGame returns the value of Game. +func (s *UserRead) GetGame() OptBool { + return s.Game +} + +// GetGameTest returns the value of GameTest. +func (s *UserRead) GetGameTest() OptBool { + return s.GameTest +} + +// GetGameEnd returns the value of GameEnd. +func (s *UserRead) GetGameEnd() OptBool { + return s.GameEnd +} + +// GetGameAccount returns the value of GameAccount. +func (s *UserRead) GetGameAccount() OptBool { + return s.GameAccount +} + +// GetGameLv returns the value of GameLv. +func (s *UserRead) GetGameLv() OptInt { + return s.GameLv +} + // SetID sets the value of ID. func (s *UserRead) SetID(val int) { s.ID = val @@ -3950,43 +4886,121 @@ func (s *UserRead) SetRoom(val OptInt) { s.Room = val } +// SetModel sets the value of Model. +func (s *UserRead) SetModel(val OptBool) { + s.Model = val +} + +// SetModelAt sets the value of ModelAt. +func (s *UserRead) SetModelAt(val OptDateTime) { + s.ModelAt = val +} + +// SetModelAttack sets the value of ModelAttack. +func (s *UserRead) SetModelAttack(val OptInt) { + s.ModelAttack = val +} + +// SetModelLimit sets the value of ModelLimit. +func (s *UserRead) SetModelLimit(val OptInt) { + s.ModelLimit = val +} + +// SetModelSkill sets the value of ModelSkill. +func (s *UserRead) SetModelSkill(val OptInt) { + s.ModelSkill = val +} + +// SetModelMode sets the value of ModelMode. +func (s *UserRead) SetModelMode(val OptInt) { + s.ModelMode = val +} + +// SetModelCritical sets the value of ModelCritical. +func (s *UserRead) SetModelCritical(val OptInt) { + s.ModelCritical = val +} + +// SetModelCriticalD sets the value of ModelCriticalD. +func (s *UserRead) SetModelCriticalD(val OptInt) { + s.ModelCriticalD = val +} + +// SetGame sets the value of Game. +func (s *UserRead) SetGame(val OptBool) { + s.Game = val +} + +// SetGameTest sets the value of GameTest. +func (s *UserRead) SetGameTest(val OptBool) { + s.GameTest = val +} + +// SetGameEnd sets the value of GameEnd. +func (s *UserRead) SetGameEnd(val OptBool) { + s.GameEnd = val +} + +// SetGameAccount sets the value of GameAccount. +func (s *UserRead) SetGameAccount(val OptBool) { + s.GameAccount = val +} + +// SetGameLv sets the value of GameLv. +func (s *UserRead) SetGameLv(val OptInt) { + s.GameLv = val +} + func (*UserRead) readUserRes() {} // Ref: #/components/schemas/UserUpdate type UserUpdate struct { - ID int `json:"id"` - Username string `json:"username"` - Did OptString `json:"did"` - Member OptBool `json:"member"` - Book OptBool `json:"book"` - Manga OptBool `json:"manga"` - Badge OptBool `json:"badge"` - Bsky OptBool `json:"bsky"` - Mastodon OptBool `json:"mastodon"` - Delete OptBool `json:"delete"` - Handle OptBool `json:"handle"` - CreatedAt OptDateTime `json:"created_at"` - UpdatedAt OptDateTime `json:"updated_at"` - RaidAt OptDateTime `json:"raid_at"` - ServerAt OptDateTime `json:"server_at"` - EggAt OptDateTime `json:"egg_at"` - Luck OptInt `json:"luck"` - LuckAt OptDateTime `json:"luck_at"` - Like OptInt `json:"like"` - LikeRank OptInt `json:"like_rank"` - LikeAt OptDateTime `json:"like_at"` - Fav OptInt `json:"fav"` - Ten OptBool `json:"ten"` - TenSu OptInt `json:"ten_su"` - TenKai OptInt `json:"ten_kai"` - Aiten OptInt `json:"aiten"` - TenCard OptString `json:"ten_card"` - TenDelete OptString `json:"ten_delete"` - TenPost OptString `json:"ten_post"` - TenGet OptString `json:"ten_get"` - TenAt OptDateTime `json:"ten_at"` - Next OptString `json:"next"` - Room OptInt `json:"room"` + ID int `json:"id"` + Username string `json:"username"` + Did OptString `json:"did"` + Member OptBool `json:"member"` + Book OptBool `json:"book"` + Manga OptBool `json:"manga"` + Badge OptBool `json:"badge"` + Bsky OptBool `json:"bsky"` + Mastodon OptBool `json:"mastodon"` + Delete OptBool `json:"delete"` + Handle OptBool `json:"handle"` + CreatedAt OptDateTime `json:"created_at"` + UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + ServerAt OptDateTime `json:"server_at"` + EggAt OptDateTime `json:"egg_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + Fav OptInt `json:"fav"` + Ten OptBool `json:"ten"` + TenSu OptInt `json:"ten_su"` + TenKai OptInt `json:"ten_kai"` + Aiten OptInt `json:"aiten"` + TenCard OptString `json:"ten_card"` + TenDelete OptString `json:"ten_delete"` + TenPost OptString `json:"ten_post"` + TenGet OptString `json:"ten_get"` + TenAt OptDateTime `json:"ten_at"` + Next OptString `json:"next"` + Room OptInt `json:"room"` + Model OptBool `json:"model"` + ModelAt OptDateTime `json:"model_at"` + ModelAttack OptInt `json:"model_attack"` + ModelLimit OptInt `json:"model_limit"` + ModelSkill OptInt `json:"model_skill"` + ModelMode OptInt `json:"model_mode"` + ModelCritical OptInt `json:"model_critical"` + ModelCriticalD OptInt `json:"model_critical_d"` + Game OptBool `json:"game"` + GameTest OptBool `json:"game_test"` + GameEnd OptBool `json:"game_end"` + GameAccount OptBool `json:"game_account"` + GameLv OptInt `json:"game_lv"` } // GetID returns the value of ID. @@ -4154,6 +5168,71 @@ func (s *UserUpdate) GetRoom() OptInt { return s.Room } +// GetModel returns the value of Model. +func (s *UserUpdate) GetModel() OptBool { + return s.Model +} + +// GetModelAt returns the value of ModelAt. +func (s *UserUpdate) GetModelAt() OptDateTime { + return s.ModelAt +} + +// GetModelAttack returns the value of ModelAttack. +func (s *UserUpdate) GetModelAttack() OptInt { + return s.ModelAttack +} + +// GetModelLimit returns the value of ModelLimit. +func (s *UserUpdate) GetModelLimit() OptInt { + return s.ModelLimit +} + +// GetModelSkill returns the value of ModelSkill. +func (s *UserUpdate) GetModelSkill() OptInt { + return s.ModelSkill +} + +// GetModelMode returns the value of ModelMode. +func (s *UserUpdate) GetModelMode() OptInt { + return s.ModelMode +} + +// GetModelCritical returns the value of ModelCritical. +func (s *UserUpdate) GetModelCritical() OptInt { + return s.ModelCritical +} + +// GetModelCriticalD returns the value of ModelCriticalD. +func (s *UserUpdate) GetModelCriticalD() OptInt { + return s.ModelCriticalD +} + +// GetGame returns the value of Game. +func (s *UserUpdate) GetGame() OptBool { + return s.Game +} + +// GetGameTest returns the value of GameTest. +func (s *UserUpdate) GetGameTest() OptBool { + return s.GameTest +} + +// GetGameEnd returns the value of GameEnd. +func (s *UserUpdate) GetGameEnd() OptBool { + return s.GameEnd +} + +// GetGameAccount returns the value of GameAccount. +func (s *UserUpdate) GetGameAccount() OptBool { + return s.GameAccount +} + +// GetGameLv returns the value of GameLv. +func (s *UserUpdate) GetGameLv() OptInt { + return s.GameLv +} + // SetID sets the value of ID. func (s *UserUpdate) SetID(val int) { s.ID = val @@ -4319,4 +5398,69 @@ func (s *UserUpdate) SetRoom(val OptInt) { s.Room = val } +// SetModel sets the value of Model. +func (s *UserUpdate) SetModel(val OptBool) { + s.Model = val +} + +// SetModelAt sets the value of ModelAt. +func (s *UserUpdate) SetModelAt(val OptDateTime) { + s.ModelAt = val +} + +// SetModelAttack sets the value of ModelAttack. +func (s *UserUpdate) SetModelAttack(val OptInt) { + s.ModelAttack = val +} + +// SetModelLimit sets the value of ModelLimit. +func (s *UserUpdate) SetModelLimit(val OptInt) { + s.ModelLimit = val +} + +// SetModelSkill sets the value of ModelSkill. +func (s *UserUpdate) SetModelSkill(val OptInt) { + s.ModelSkill = val +} + +// SetModelMode sets the value of ModelMode. +func (s *UserUpdate) SetModelMode(val OptInt) { + s.ModelMode = val +} + +// SetModelCritical sets the value of ModelCritical. +func (s *UserUpdate) SetModelCritical(val OptInt) { + s.ModelCritical = val +} + +// SetModelCriticalD sets the value of ModelCriticalD. +func (s *UserUpdate) SetModelCriticalD(val OptInt) { + s.ModelCriticalD = val +} + +// SetGame sets the value of Game. +func (s *UserUpdate) SetGame(val OptBool) { + s.Game = val +} + +// SetGameTest sets the value of GameTest. +func (s *UserUpdate) SetGameTest(val OptBool) { + s.GameTest = val +} + +// SetGameEnd sets the value of GameEnd. +func (s *UserUpdate) SetGameEnd(val OptBool) { + s.GameEnd = val +} + +// SetGameAccount sets the value of GameAccount. +func (s *UserUpdate) SetGameAccount(val OptBool) { + s.GameAccount = val +} + +// SetGameLv sets the value of GameLv. +func (s *UserUpdate) SetGameLv(val OptInt) { + s.GameLv = val +} + func (*UserUpdate) updateUserRes() {} diff --git a/ent/ogent/ogent.go b/ent/ogent/ogent.go index 9d568ca..3dfede2 100644 --- a/ent/ogent/ogent.go +++ b/ent/ogent/ogent.go @@ -603,6 +603,46 @@ func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (Crea if v, ok := req.Next.Get(); ok { b.SetNext(v) } + if v, ok := req.Model.Get(); ok { + b.SetModel(v) + } + if v, ok := req.ModelAt.Get(); ok { + b.SetModelAt(v) + } + if v, ok := req.ModelAttack.Get(); ok { + b.SetModelAttack(v) + } + if v, ok := req.ModelCriticalD.Get(); ok { + b.SetModelCriticalD(v) + } + if v, ok := req.ModelCritical.Get(); ok { + b.SetModelCritical(v) + } + if v, ok := req.ModelLimit.Get(); ok { + b.SetModelLimit(v) + } + if v, ok := req.ModelSkill.Get(); ok { + b.SetModelSkill(v) + } + if v, ok := req.ModelMode.Get(); ok { + b.SetModelMode(v) + } + if v, ok := req.Game.Get(); ok { + b.SetGame(v) + } + if v, ok := req.GameTest.Get(); ok { + b.SetGameTest(v) + } + if v, ok := req.GameEnd.Get(); ok { + b.SetGameEnd(v) + } + if v, ok := req.GameAccount.Get(); ok { + b.SetGameAccount(v) + } + if v, ok := req.GameLv.Get(); ok { + b.SetGameLv(v) + } + // Add all edges. b.AddCardIDs(req.Card...) // Persist to storage. @@ -760,6 +800,45 @@ func (h *OgentHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, param if v, ok := req.Next.Get(); ok { b.SetNext(v) } + if v, ok := req.Model.Get(); ok { + b.SetModel(v) + } + if v, ok := req.ModelAt.Get(); ok { + b.SetModelAt(v) + } + if v, ok := req.ModelAttack.Get(); ok { + b.SetModelAttack(v) + } + if v, ok := req.ModelCriticalD.Get(); ok { + b.SetModelCriticalD(v) + } + if v, ok := req.ModelCritical.Get(); ok { + b.SetModelCritical(v) + } + if v, ok := req.ModelLimit.Get(); ok { + b.SetModelLimit(v) + } + if v, ok := req.ModelSkill.Get(); ok { + b.SetModelSkill(v) + } + if v, ok := req.ModelMode.Get(); ok { + b.SetModelMode(v) + } + if v, ok := req.Game.Get(); ok { + b.SetGame(v) + } + if v, ok := req.GameTest.Get(); ok { + b.SetGameTest(v) + } + if v, ok := req.GameEnd.Get(); ok { + b.SetGameEnd(v) + } + if v, ok := req.GameAccount.Get(); ok { + b.SetGameAccount(v) + } + if v, ok := req.GameLv.Get(); ok { + b.SetGameLv(v) + } // Add all edges. if req.Card != nil { b.ClearCard().AddCardIDs(req.Card...) diff --git a/ent/ogent/responses.go b/ent/ogent/responses.go index f184353..c8f29f4 100644 --- a/ent/ogent/responses.go +++ b/ent/ogent/responses.go @@ -182,6 +182,19 @@ func NewCardOwnerRead(e *ent.User) *CardOwnerRead { ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) ret.Room = NewOptInt(e.Room) + ret.Model = NewOptBool(e.Model) + ret.ModelAt = NewOptDateTime(e.ModelAt) + ret.ModelAttack = NewOptInt(e.ModelAttack) + ret.ModelLimit = NewOptInt(e.ModelLimit) + ret.ModelSkill = NewOptInt(e.ModelSkill) + ret.ModelMode = NewOptInt(e.ModelMode) + ret.ModelCritical = NewOptInt(e.ModelCritical) + ret.ModelCriticalD = NewOptInt(e.ModelCriticalD) + ret.Game = NewOptBool(e.Game) + ret.GameTest = NewOptBool(e.GameTest) + ret.GameEnd = NewOptBool(e.GameEnd) + ret.GameAccount = NewOptBool(e.GameAccount) + ret.GameLv = NewOptInt(e.GameLv) return &ret } @@ -353,6 +366,19 @@ func NewGroupUsersList(e *ent.User) *GroupUsersList { ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) ret.Room = NewOptInt(e.Room) + ret.Model = NewOptBool(e.Model) + ret.ModelAt = NewOptDateTime(e.ModelAt) + ret.ModelAttack = NewOptInt(e.ModelAttack) + ret.ModelLimit = NewOptInt(e.ModelLimit) + ret.ModelSkill = NewOptInt(e.ModelSkill) + ret.ModelMode = NewOptInt(e.ModelMode) + ret.ModelCritical = NewOptInt(e.ModelCritical) + ret.ModelCriticalD = NewOptInt(e.ModelCriticalD) + ret.Game = NewOptBool(e.Game) + ret.GameTest = NewOptBool(e.GameTest) + ret.GameEnd = NewOptBool(e.GameEnd) + ret.GameAccount = NewOptBool(e.GameAccount) + ret.GameLv = NewOptInt(e.GameLv) return &ret } @@ -412,6 +438,19 @@ func NewUserCreate(e *ent.User) *UserCreate { ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) ret.Room = NewOptInt(e.Room) + ret.Model = NewOptBool(e.Model) + ret.ModelAt = NewOptDateTime(e.ModelAt) + ret.ModelAttack = NewOptInt(e.ModelAttack) + ret.ModelLimit = NewOptInt(e.ModelLimit) + ret.ModelSkill = NewOptInt(e.ModelSkill) + ret.ModelMode = NewOptInt(e.ModelMode) + ret.ModelCritical = NewOptInt(e.ModelCritical) + ret.ModelCriticalD = NewOptInt(e.ModelCriticalD) + ret.Game = NewOptBool(e.Game) + ret.GameTest = NewOptBool(e.GameTest) + ret.GameEnd = NewOptBool(e.GameEnd) + ret.GameAccount = NewOptBool(e.GameAccount) + ret.GameLv = NewOptInt(e.GameLv) return &ret } @@ -471,6 +510,19 @@ func NewUserList(e *ent.User) *UserList { ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) ret.Room = NewOptInt(e.Room) + ret.Model = NewOptBool(e.Model) + ret.ModelAt = NewOptDateTime(e.ModelAt) + ret.ModelAttack = NewOptInt(e.ModelAttack) + ret.ModelLimit = NewOptInt(e.ModelLimit) + ret.ModelSkill = NewOptInt(e.ModelSkill) + ret.ModelMode = NewOptInt(e.ModelMode) + ret.ModelCritical = NewOptInt(e.ModelCritical) + ret.ModelCriticalD = NewOptInt(e.ModelCriticalD) + ret.Game = NewOptBool(e.Game) + ret.GameTest = NewOptBool(e.GameTest) + ret.GameEnd = NewOptBool(e.GameEnd) + ret.GameAccount = NewOptBool(e.GameAccount) + ret.GameLv = NewOptInt(e.GameLv) return &ret } @@ -530,6 +582,19 @@ func NewUserRead(e *ent.User) *UserRead { ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) ret.Room = NewOptInt(e.Room) + ret.Model = NewOptBool(e.Model) + ret.ModelAt = NewOptDateTime(e.ModelAt) + ret.ModelAttack = NewOptInt(e.ModelAttack) + ret.ModelLimit = NewOptInt(e.ModelLimit) + ret.ModelSkill = NewOptInt(e.ModelSkill) + ret.ModelMode = NewOptInt(e.ModelMode) + ret.ModelCritical = NewOptInt(e.ModelCritical) + ret.ModelCriticalD = NewOptInt(e.ModelCriticalD) + ret.Game = NewOptBool(e.Game) + ret.GameTest = NewOptBool(e.GameTest) + ret.GameEnd = NewOptBool(e.GameEnd) + ret.GameAccount = NewOptBool(e.GameAccount) + ret.GameLv = NewOptInt(e.GameLv) return &ret } @@ -589,6 +654,19 @@ func NewUserUpdate(e *ent.User) *UserUpdate { ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) ret.Room = NewOptInt(e.Room) + ret.Model = NewOptBool(e.Model) + ret.ModelAt = NewOptDateTime(e.ModelAt) + ret.ModelAttack = NewOptInt(e.ModelAttack) + ret.ModelLimit = NewOptInt(e.ModelLimit) + ret.ModelSkill = NewOptInt(e.ModelSkill) + ret.ModelMode = NewOptInt(e.ModelMode) + ret.ModelCritical = NewOptInt(e.ModelCritical) + ret.ModelCriticalD = NewOptInt(e.ModelCriticalD) + ret.Game = NewOptBool(e.Game) + ret.GameTest = NewOptBool(e.GameTest) + ret.GameEnd = NewOptBool(e.GameEnd) + ret.GameAccount = NewOptBool(e.GameAccount) + ret.GameLv = NewOptInt(e.GameLv) return &ret } diff --git a/ent/openapi.json b/ent/openapi.json index 2122191..03dcf71 100644 --- a/ent/openapi.json +++ b/ent/openapi.json @@ -885,6 +885,46 @@ "room": { "type": "integer" }, + "model": { + "type": "boolean" + }, + "model_at": { + "type": "string", + "format": "date-time" + }, + "model_attack": { + "type": "integer" + }, + "model_limit": { + "type": "integer" + }, + "model_skill": { + "type": "integer" + }, + "model_mode": { + "type": "integer" + }, + "model_critical": { + "type": "integer" + }, + "model_critical_d": { + "type": "integer" + }, + "game": { + "type": "boolean" + }, + "game_test": { + "type": "boolean" + }, + "game_end": { + "type": "boolean" + }, + "game_account": { + "type": "boolean" + }, + "game_lv": { + "type": "integer" + }, "card": { "type": "array", "items": { @@ -1129,6 +1169,46 @@ "room": { "type": "integer" }, + "model": { + "type": "boolean" + }, + "model_at": { + "type": "string", + "format": "date-time" + }, + "model_attack": { + "type": "integer" + }, + "model_limit": { + "type": "integer" + }, + "model_skill": { + "type": "integer" + }, + "model_mode": { + "type": "integer" + }, + "model_critical": { + "type": "integer" + }, + "model_critical_d": { + "type": "integer" + }, + "game": { + "type": "boolean" + }, + "game_test": { + "type": "boolean" + }, + "game_end": { + "type": "boolean" + }, + "game_account": { + "type": "boolean" + }, + "game_lv": { + "type": "integer" + }, "card": { "type": "array", "items": { @@ -1559,6 +1639,46 @@ }, "room": { "type": "integer" + }, + "model": { + "type": "boolean" + }, + "model_at": { + "type": "string", + "format": "date-time" + }, + "model_attack": { + "type": "integer" + }, + "model_limit": { + "type": "integer" + }, + "model_skill": { + "type": "integer" + }, + "model_mode": { + "type": "integer" + }, + "model_critical": { + "type": "integer" + }, + "model_critical_d": { + "type": "integer" + }, + "game": { + "type": "boolean" + }, + "game_test": { + "type": "boolean" + }, + "game_end": { + "type": "boolean" + }, + "game_account": { + "type": "boolean" + }, + "game_lv": { + "type": "integer" } }, "required": [ @@ -1760,6 +1880,46 @@ }, "room": { "type": "integer" + }, + "model": { + "type": "boolean" + }, + "model_at": { + "type": "string", + "format": "date-time" + }, + "model_attack": { + "type": "integer" + }, + "model_limit": { + "type": "integer" + }, + "model_skill": { + "type": "integer" + }, + "model_mode": { + "type": "integer" + }, + "model_critical": { + "type": "integer" + }, + "model_critical_d": { + "type": "integer" + }, + "game": { + "type": "boolean" + }, + "game_test": { + "type": "boolean" + }, + "game_end": { + "type": "boolean" + }, + "game_account": { + "type": "boolean" + }, + "game_lv": { + "type": "integer" } }, "required": [ @@ -1883,6 +2043,46 @@ "room": { "type": "integer" }, + "model": { + "type": "boolean" + }, + "model_at": { + "type": "string", + "format": "date-time" + }, + "model_attack": { + "type": "integer" + }, + "model_limit": { + "type": "integer" + }, + "model_skill": { + "type": "integer" + }, + "model_mode": { + "type": "integer" + }, + "model_critical": { + "type": "integer" + }, + "model_critical_d": { + "type": "integer" + }, + "game": { + "type": "boolean" + }, + "game_test": { + "type": "boolean" + }, + "game_end": { + "type": "boolean" + }, + "game_account": { + "type": "boolean" + }, + "game_lv": { + "type": "integer" + }, "card": { "type": "array", "items": { @@ -2005,6 +2205,46 @@ }, "room": { "type": "integer" + }, + "model": { + "type": "boolean" + }, + "model_at": { + "type": "string", + "format": "date-time" + }, + "model_attack": { + "type": "integer" + }, + "model_limit": { + "type": "integer" + }, + "model_skill": { + "type": "integer" + }, + "model_mode": { + "type": "integer" + }, + "model_critical": { + "type": "integer" + }, + "model_critical_d": { + "type": "integer" + }, + "game": { + "type": "boolean" + }, + "game_test": { + "type": "boolean" + }, + "game_end": { + "type": "boolean" + }, + "game_account": { + "type": "boolean" + }, + "game_lv": { + "type": "integer" } }, "required": [ @@ -2121,6 +2361,46 @@ }, "room": { "type": "integer" + }, + "model": { + "type": "boolean" + }, + "model_at": { + "type": "string", + "format": "date-time" + }, + "model_attack": { + "type": "integer" + }, + "model_limit": { + "type": "integer" + }, + "model_skill": { + "type": "integer" + }, + "model_mode": { + "type": "integer" + }, + "model_critical": { + "type": "integer" + }, + "model_critical_d": { + "type": "integer" + }, + "game": { + "type": "boolean" + }, + "game_test": { + "type": "boolean" + }, + "game_end": { + "type": "boolean" + }, + "game_account": { + "type": "boolean" + }, + "game_lv": { + "type": "integer" } }, "required": [ @@ -2237,6 +2517,46 @@ }, "room": { "type": "integer" + }, + "model": { + "type": "boolean" + }, + "model_at": { + "type": "string", + "format": "date-time" + }, + "model_attack": { + "type": "integer" + }, + "model_limit": { + "type": "integer" + }, + "model_skill": { + "type": "integer" + }, + "model_mode": { + "type": "integer" + }, + "model_critical": { + "type": "integer" + }, + "model_critical_d": { + "type": "integer" + }, + "game": { + "type": "boolean" + }, + "game_test": { + "type": "boolean" + }, + "game_end": { + "type": "boolean" + }, + "game_account": { + "type": "boolean" + }, + "game_lv": { + "type": "integer" } }, "required": [ @@ -2353,6 +2673,46 @@ }, "room": { "type": "integer" + }, + "model": { + "type": "boolean" + }, + "model_at": { + "type": "string", + "format": "date-time" + }, + "model_attack": { + "type": "integer" + }, + "model_limit": { + "type": "integer" + }, + "model_skill": { + "type": "integer" + }, + "model_mode": { + "type": "integer" + }, + "model_critical": { + "type": "integer" + }, + "model_critical_d": { + "type": "integer" + }, + "game": { + "type": "boolean" + }, + "game_test": { + "type": "boolean" + }, + "game_end": { + "type": "boolean" + }, + "game_account": { + "type": "boolean" + }, + "game_lv": { + "type": "integer" } }, "required": [ diff --git a/ent/runtime.go b/ent/runtime.go index 98370f7..8423679 100644 --- a/ent/runtime.go +++ b/ent/runtime.go @@ -142,4 +142,24 @@ func init() { userDescNext := userFields[32].Descriptor() // user.DefaultNext holds the default value on creation for the next field. user.DefaultNext = userDescNext.Default.(string) + // userDescModelAt is the schema descriptor for model_at field. + userDescModelAt := userFields[35].Descriptor() + // user.DefaultModelAt holds the default value on creation for the model_at field. + user.DefaultModelAt = userDescModelAt.Default.(func() time.Time) + // userDescGame is the schema descriptor for game field. + userDescGame := userFields[42].Descriptor() + // user.DefaultGame holds the default value on creation for the game field. + user.DefaultGame = userDescGame.Default.(bool) + // userDescGameTest is the schema descriptor for game_test field. + userDescGameTest := userFields[43].Descriptor() + // user.DefaultGameTest holds the default value on creation for the game_test field. + user.DefaultGameTest = userDescGameTest.Default.(bool) + // userDescGameEnd is the schema descriptor for game_end field. + userDescGameEnd := userFields[44].Descriptor() + // user.DefaultGameEnd holds the default value on creation for the game_end field. + user.DefaultGameEnd = userDescGameEnd.Default.(bool) + // userDescGameAccount is the schema descriptor for game_account field. + userDescGameAccount := userFields[45].Descriptor() + // user.DefaultGameAccount holds the default value on creation for the game_account field. + user.DefaultGameAccount = userDescGameAccount.Default.(bool) } diff --git a/ent/schema/card.go b/ent/schema/card.go index 6a0e415..fb97387 100644 --- a/ent/schema/card.go +++ b/ent/schema/card.go @@ -58,6 +58,7 @@ func (Card) Fields() []ent.Field { card = 6 } + //var card = rand.Intn(91) return card }). Optional(), diff --git a/ent/schema/user.go b/ent/schema/user.go index 286d171..44a3f9e 100644 --- a/ent/schema/user.go +++ b/ent/schema/user.go @@ -171,6 +171,51 @@ func (User) Fields() []ent.Field { field.Int("room"). Optional(), + field.Bool("model"). + Optional(), + + field.Time("model_at"). + Optional(). + Default(func() time.Time { + return time.Now().In(jst) + }), + + field.Int("model_attack"). + Optional(), + + field.Int("model_limit"). + Optional(), + + field.Int("model_skill"). + Optional(), + + field.Int("model_mode"). + Optional(), + + field.Int("model_critical"). + Optional(), + + field.Int("model_critical_d"). + Optional(), + + field.Bool("game"). + Default(false). + Optional(), + + field.Bool("game_test"). + Default(false). + Optional(), + + field.Bool("game_end"). + Default(false). + Optional(), + + field.Bool("game_account"). + Default(false). + Optional(), + + field.Int("game_lv"). + Optional(), } } diff --git a/ent/user.go b/ent/user.go index 67f92cd..4d654a5 100644 --- a/ent/user.go +++ b/ent/user.go @@ -84,6 +84,32 @@ type User struct { Next string `json:"next,omitempty"` // Room holds the value of the "room" field. Room int `json:"room,omitempty"` + // Model holds the value of the "model" field. + Model bool `json:"model,omitempty"` + // ModelAt holds the value of the "model_at" field. + ModelAt time.Time `json:"model_at,omitempty"` + // ModelAttack holds the value of the "model_attack" field. + ModelAttack int `json:"model_attack,omitempty"` + // ModelLimit holds the value of the "model_limit" field. + ModelLimit int `json:"model_limit,omitempty"` + // ModelSkill holds the value of the "model_skill" field. + ModelSkill int `json:"model_skill,omitempty"` + // ModelMode holds the value of the "model_mode" field. + ModelMode int `json:"model_mode,omitempty"` + // ModelCritical holds the value of the "model_critical" field. + ModelCritical int `json:"model_critical,omitempty"` + // ModelCriticalD holds the value of the "model_critical_d" field. + ModelCriticalD int `json:"model_critical_d,omitempty"` + // Game holds the value of the "game" field. + Game bool `json:"game,omitempty"` + // GameTest holds the value of the "game_test" field. + GameTest bool `json:"game_test,omitempty"` + // GameEnd holds the value of the "game_end" field. + GameEnd bool `json:"game_end,omitempty"` + // GameAccount holds the value of the "game_account" field. + GameAccount bool `json:"game_account,omitempty"` + // GameLv holds the value of the "game_lv" field. + GameLv int `json:"game_lv,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"` @@ -113,13 +139,13 @@ func (*User) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) for i := range columns { switch columns[i] { - case user.FieldMember, user.FieldBook, user.FieldManga, user.FieldBadge, user.FieldBsky, user.FieldMastodon, user.FieldDelete, user.FieldHandle, user.FieldTen: + case user.FieldMember, user.FieldBook, user.FieldManga, user.FieldBadge, user.FieldBsky, user.FieldMastodon, user.FieldDelete, user.FieldHandle, user.FieldTen, user.FieldModel, user.FieldGame, user.FieldGameTest, user.FieldGameEnd, user.FieldGameAccount: values[i] = new(sql.NullBool) - case user.FieldID, user.FieldLuck, user.FieldLike, user.FieldLikeRank, user.FieldFav, user.FieldTenSu, user.FieldTenKai, user.FieldAiten, user.FieldRoom: + case user.FieldID, user.FieldLuck, user.FieldLike, user.FieldLikeRank, user.FieldFav, user.FieldTenSu, user.FieldTenKai, user.FieldAiten, user.FieldRoom, user.FieldModelAttack, user.FieldModelLimit, user.FieldModelSkill, user.FieldModelMode, user.FieldModelCritical, user.FieldModelCriticalD, user.FieldGameLv: values[i] = new(sql.NullInt64) case user.FieldUsername, user.FieldDid, user.FieldToken, user.FieldPassword, user.FieldTenCard, user.FieldTenDelete, user.FieldTenPost, user.FieldTenGet, user.FieldNext: values[i] = new(sql.NullString) - case user.FieldCreatedAt, user.FieldUpdatedAt, user.FieldRaidAt, user.FieldServerAt, user.FieldEggAt, user.FieldLuckAt, user.FieldLikeAt, user.FieldTenAt: + case user.FieldCreatedAt, user.FieldUpdatedAt, user.FieldRaidAt, user.FieldServerAt, user.FieldEggAt, user.FieldLuckAt, user.FieldLikeAt, user.FieldTenAt, user.FieldModelAt: values[i] = new(sql.NullTime) case user.ForeignKeys[0]: // group_users values[i] = new(sql.NullInt64) @@ -348,6 +374,84 @@ func (u *User) assignValues(columns []string, values []any) error { } else if value.Valid { u.Room = int(value.Int64) } + case user.FieldModel: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field model", values[i]) + } else if value.Valid { + u.Model = value.Bool + } + case user.FieldModelAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field model_at", values[i]) + } else if value.Valid { + u.ModelAt = value.Time + } + case user.FieldModelAttack: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field model_attack", values[i]) + } else if value.Valid { + u.ModelAttack = int(value.Int64) + } + case user.FieldModelLimit: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field model_limit", values[i]) + } else if value.Valid { + u.ModelLimit = int(value.Int64) + } + case user.FieldModelSkill: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field model_skill", values[i]) + } else if value.Valid { + u.ModelSkill = int(value.Int64) + } + case user.FieldModelMode: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field model_mode", values[i]) + } else if value.Valid { + u.ModelMode = int(value.Int64) + } + case user.FieldModelCritical: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field model_critical", values[i]) + } else if value.Valid { + u.ModelCritical = int(value.Int64) + } + case user.FieldModelCriticalD: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field model_critical_d", values[i]) + } else if value.Valid { + u.ModelCriticalD = int(value.Int64) + } + case user.FieldGame: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field game", values[i]) + } else if value.Valid { + u.Game = value.Bool + } + case user.FieldGameTest: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field game_test", values[i]) + } else if value.Valid { + u.GameTest = value.Bool + } + case user.FieldGameEnd: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field game_end", values[i]) + } else if value.Valid { + u.GameEnd = value.Bool + } + case user.FieldGameAccount: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field game_account", values[i]) + } else if value.Valid { + u.GameAccount = value.Bool + } + case user.FieldGameLv: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field game_lv", values[i]) + } else if value.Valid { + u.GameLv = int(value.Int64) + } case user.ForeignKeys[0]: if value, ok := values[i].(*sql.NullInt64); !ok { return fmt.Errorf("unexpected type %T for edge-field group_users", value) @@ -487,6 +591,45 @@ func (u *User) String() string { builder.WriteString(", ") builder.WriteString("room=") builder.WriteString(fmt.Sprintf("%v", u.Room)) + builder.WriteString(", ") + builder.WriteString("model=") + builder.WriteString(fmt.Sprintf("%v", u.Model)) + builder.WriteString(", ") + builder.WriteString("model_at=") + builder.WriteString(u.ModelAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("model_attack=") + builder.WriteString(fmt.Sprintf("%v", u.ModelAttack)) + builder.WriteString(", ") + builder.WriteString("model_limit=") + builder.WriteString(fmt.Sprintf("%v", u.ModelLimit)) + builder.WriteString(", ") + builder.WriteString("model_skill=") + builder.WriteString(fmt.Sprintf("%v", u.ModelSkill)) + builder.WriteString(", ") + builder.WriteString("model_mode=") + builder.WriteString(fmt.Sprintf("%v", u.ModelMode)) + builder.WriteString(", ") + builder.WriteString("model_critical=") + builder.WriteString(fmt.Sprintf("%v", u.ModelCritical)) + builder.WriteString(", ") + builder.WriteString("model_critical_d=") + builder.WriteString(fmt.Sprintf("%v", u.ModelCriticalD)) + builder.WriteString(", ") + builder.WriteString("game=") + builder.WriteString(fmt.Sprintf("%v", u.Game)) + builder.WriteString(", ") + builder.WriteString("game_test=") + builder.WriteString(fmt.Sprintf("%v", u.GameTest)) + builder.WriteString(", ") + builder.WriteString("game_end=") + builder.WriteString(fmt.Sprintf("%v", u.GameEnd)) + builder.WriteString(", ") + builder.WriteString("game_account=") + builder.WriteString(fmt.Sprintf("%v", u.GameAccount)) + builder.WriteString(", ") + builder.WriteString("game_lv=") + builder.WriteString(fmt.Sprintf("%v", u.GameLv)) builder.WriteByte(')') return builder.String() } diff --git a/ent/user/user.go b/ent/user/user.go index ac93e1e..41fbbc7 100644 --- a/ent/user/user.go +++ b/ent/user/user.go @@ -79,6 +79,32 @@ const ( FieldNext = "next" // FieldRoom holds the string denoting the room field in the database. FieldRoom = "room" + // FieldModel holds the string denoting the model field in the database. + FieldModel = "model" + // FieldModelAt holds the string denoting the model_at field in the database. + FieldModelAt = "model_at" + // FieldModelAttack holds the string denoting the model_attack field in the database. + FieldModelAttack = "model_attack" + // FieldModelLimit holds the string denoting the model_limit field in the database. + FieldModelLimit = "model_limit" + // FieldModelSkill holds the string denoting the model_skill field in the database. + FieldModelSkill = "model_skill" + // FieldModelMode holds the string denoting the model_mode field in the database. + FieldModelMode = "model_mode" + // FieldModelCritical holds the string denoting the model_critical field in the database. + FieldModelCritical = "model_critical" + // FieldModelCriticalD holds the string denoting the model_critical_d field in the database. + FieldModelCriticalD = "model_critical_d" + // FieldGame holds the string denoting the game field in the database. + FieldGame = "game" + // FieldGameTest holds the string denoting the game_test field in the database. + FieldGameTest = "game_test" + // FieldGameEnd holds the string denoting the game_end field in the database. + FieldGameEnd = "game_end" + // FieldGameAccount holds the string denoting the game_account field in the database. + FieldGameAccount = "game_account" + // FieldGameLv holds the string denoting the game_lv field in the database. + FieldGameLv = "game_lv" // EdgeCard holds the string denoting the card edge name in mutations. EdgeCard = "card" // Table holds the table name of the user in the database. @@ -129,6 +155,19 @@ var Columns = []string{ FieldTenAt, FieldNext, FieldRoom, + FieldModel, + FieldModelAt, + FieldModelAttack, + FieldModelLimit, + FieldModelSkill, + FieldModelMode, + FieldModelCritical, + FieldModelCriticalD, + FieldGame, + FieldGameTest, + FieldGameEnd, + FieldGameAccount, + FieldGameLv, } // ForeignKeys holds the SQL foreign-keys that are owned by the "users" @@ -191,4 +230,14 @@ var ( DefaultTenAt func() time.Time // DefaultNext holds the default value on creation for the "next" field. DefaultNext string + // DefaultModelAt holds the default value on creation for the "model_at" field. + DefaultModelAt func() time.Time + // DefaultGame holds the default value on creation for the "game" field. + DefaultGame bool + // DefaultGameTest holds the default value on creation for the "game_test" field. + DefaultGameTest bool + // DefaultGameEnd holds the default value on creation for the "game_end" field. + DefaultGameEnd bool + // DefaultGameAccount holds the default value on creation for the "game_account" field. + DefaultGameAccount bool ) diff --git a/ent/user/where.go b/ent/user/where.go index 447650c..c9684a5 100644 --- a/ent/user/where.go +++ b/ent/user/where.go @@ -225,6 +225,71 @@ func Room(v int) predicate.User { return predicate.User(sql.FieldEQ(FieldRoom, v)) } +// Model applies equality check predicate on the "model" field. It's identical to ModelEQ. +func Model(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldModel, v)) +} + +// ModelAt applies equality check predicate on the "model_at" field. It's identical to ModelAtEQ. +func ModelAt(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelAt, v)) +} + +// ModelAttack applies equality check predicate on the "model_attack" field. It's identical to ModelAttackEQ. +func ModelAttack(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelAttack, v)) +} + +// ModelLimit applies equality check predicate on the "model_limit" field. It's identical to ModelLimitEQ. +func ModelLimit(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelLimit, v)) +} + +// ModelSkill applies equality check predicate on the "model_skill" field. It's identical to ModelSkillEQ. +func ModelSkill(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelSkill, v)) +} + +// ModelMode applies equality check predicate on the "model_mode" field. It's identical to ModelModeEQ. +func ModelMode(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelMode, v)) +} + +// ModelCritical applies equality check predicate on the "model_critical" field. It's identical to ModelCriticalEQ. +func ModelCritical(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelCritical, v)) +} + +// ModelCriticalD applies equality check predicate on the "model_critical_d" field. It's identical to ModelCriticalDEQ. +func ModelCriticalD(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelCriticalD, v)) +} + +// Game applies equality check predicate on the "game" field. It's identical to GameEQ. +func Game(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldGame, v)) +} + +// GameTest applies equality check predicate on the "game_test" field. It's identical to GameTestEQ. +func GameTest(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldGameTest, v)) +} + +// GameEnd applies equality check predicate on the "game_end" field. It's identical to GameEndEQ. +func GameEnd(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldGameEnd, v)) +} + +// GameAccount applies equality check predicate on the "game_account" field. It's identical to GameAccountEQ. +func GameAccount(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldGameAccount, v)) +} + +// GameLv applies equality check predicate on the "game_lv" field. It's identical to GameLvEQ. +func GameLv(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldGameLv, v)) +} + // UsernameEQ applies the EQ predicate on the "username" field. func UsernameEQ(v string) predicate.User { return predicate.User(sql.FieldEQ(FieldUsername, v)) @@ -1860,6 +1925,506 @@ func RoomNotNil() predicate.User { return predicate.User(sql.FieldNotNull(FieldRoom)) } +// ModelEQ applies the EQ predicate on the "model" field. +func ModelEQ(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldModel, v)) +} + +// ModelNEQ applies the NEQ predicate on the "model" field. +func ModelNEQ(v bool) predicate.User { + return predicate.User(sql.FieldNEQ(FieldModel, v)) +} + +// ModelIsNil applies the IsNil predicate on the "model" field. +func ModelIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldModel)) +} + +// ModelNotNil applies the NotNil predicate on the "model" field. +func ModelNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldModel)) +} + +// ModelAtEQ applies the EQ predicate on the "model_at" field. +func ModelAtEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelAt, v)) +} + +// ModelAtNEQ applies the NEQ predicate on the "model_at" field. +func ModelAtNEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldNEQ(FieldModelAt, v)) +} + +// ModelAtIn applies the In predicate on the "model_at" field. +func ModelAtIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldIn(FieldModelAt, vs...)) +} + +// ModelAtNotIn applies the NotIn predicate on the "model_at" field. +func ModelAtNotIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldNotIn(FieldModelAt, vs...)) +} + +// ModelAtGT applies the GT predicate on the "model_at" field. +func ModelAtGT(v time.Time) predicate.User { + return predicate.User(sql.FieldGT(FieldModelAt, v)) +} + +// ModelAtGTE applies the GTE predicate on the "model_at" field. +func ModelAtGTE(v time.Time) predicate.User { + return predicate.User(sql.FieldGTE(FieldModelAt, v)) +} + +// ModelAtLT applies the LT predicate on the "model_at" field. +func ModelAtLT(v time.Time) predicate.User { + return predicate.User(sql.FieldLT(FieldModelAt, v)) +} + +// ModelAtLTE applies the LTE predicate on the "model_at" field. +func ModelAtLTE(v time.Time) predicate.User { + return predicate.User(sql.FieldLTE(FieldModelAt, v)) +} + +// ModelAtIsNil applies the IsNil predicate on the "model_at" field. +func ModelAtIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldModelAt)) +} + +// ModelAtNotNil applies the NotNil predicate on the "model_at" field. +func ModelAtNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldModelAt)) +} + +// ModelAttackEQ applies the EQ predicate on the "model_attack" field. +func ModelAttackEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelAttack, v)) +} + +// ModelAttackNEQ applies the NEQ predicate on the "model_attack" field. +func ModelAttackNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldModelAttack, v)) +} + +// ModelAttackIn applies the In predicate on the "model_attack" field. +func ModelAttackIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldModelAttack, vs...)) +} + +// ModelAttackNotIn applies the NotIn predicate on the "model_attack" field. +func ModelAttackNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldModelAttack, vs...)) +} + +// ModelAttackGT applies the GT predicate on the "model_attack" field. +func ModelAttackGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldModelAttack, v)) +} + +// ModelAttackGTE applies the GTE predicate on the "model_attack" field. +func ModelAttackGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldModelAttack, v)) +} + +// ModelAttackLT applies the LT predicate on the "model_attack" field. +func ModelAttackLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldModelAttack, v)) +} + +// ModelAttackLTE applies the LTE predicate on the "model_attack" field. +func ModelAttackLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldModelAttack, v)) +} + +// ModelAttackIsNil applies the IsNil predicate on the "model_attack" field. +func ModelAttackIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldModelAttack)) +} + +// ModelAttackNotNil applies the NotNil predicate on the "model_attack" field. +func ModelAttackNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldModelAttack)) +} + +// ModelLimitEQ applies the EQ predicate on the "model_limit" field. +func ModelLimitEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelLimit, v)) +} + +// ModelLimitNEQ applies the NEQ predicate on the "model_limit" field. +func ModelLimitNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldModelLimit, v)) +} + +// ModelLimitIn applies the In predicate on the "model_limit" field. +func ModelLimitIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldModelLimit, vs...)) +} + +// ModelLimitNotIn applies the NotIn predicate on the "model_limit" field. +func ModelLimitNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldModelLimit, vs...)) +} + +// ModelLimitGT applies the GT predicate on the "model_limit" field. +func ModelLimitGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldModelLimit, v)) +} + +// ModelLimitGTE applies the GTE predicate on the "model_limit" field. +func ModelLimitGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldModelLimit, v)) +} + +// ModelLimitLT applies the LT predicate on the "model_limit" field. +func ModelLimitLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldModelLimit, v)) +} + +// ModelLimitLTE applies the LTE predicate on the "model_limit" field. +func ModelLimitLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldModelLimit, v)) +} + +// ModelLimitIsNil applies the IsNil predicate on the "model_limit" field. +func ModelLimitIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldModelLimit)) +} + +// ModelLimitNotNil applies the NotNil predicate on the "model_limit" field. +func ModelLimitNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldModelLimit)) +} + +// ModelSkillEQ applies the EQ predicate on the "model_skill" field. +func ModelSkillEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelSkill, v)) +} + +// ModelSkillNEQ applies the NEQ predicate on the "model_skill" field. +func ModelSkillNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldModelSkill, v)) +} + +// ModelSkillIn applies the In predicate on the "model_skill" field. +func ModelSkillIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldModelSkill, vs...)) +} + +// ModelSkillNotIn applies the NotIn predicate on the "model_skill" field. +func ModelSkillNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldModelSkill, vs...)) +} + +// ModelSkillGT applies the GT predicate on the "model_skill" field. +func ModelSkillGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldModelSkill, v)) +} + +// ModelSkillGTE applies the GTE predicate on the "model_skill" field. +func ModelSkillGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldModelSkill, v)) +} + +// ModelSkillLT applies the LT predicate on the "model_skill" field. +func ModelSkillLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldModelSkill, v)) +} + +// ModelSkillLTE applies the LTE predicate on the "model_skill" field. +func ModelSkillLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldModelSkill, v)) +} + +// ModelSkillIsNil applies the IsNil predicate on the "model_skill" field. +func ModelSkillIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldModelSkill)) +} + +// ModelSkillNotNil applies the NotNil predicate on the "model_skill" field. +func ModelSkillNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldModelSkill)) +} + +// ModelModeEQ applies the EQ predicate on the "model_mode" field. +func ModelModeEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelMode, v)) +} + +// ModelModeNEQ applies the NEQ predicate on the "model_mode" field. +func ModelModeNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldModelMode, v)) +} + +// ModelModeIn applies the In predicate on the "model_mode" field. +func ModelModeIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldModelMode, vs...)) +} + +// ModelModeNotIn applies the NotIn predicate on the "model_mode" field. +func ModelModeNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldModelMode, vs...)) +} + +// ModelModeGT applies the GT predicate on the "model_mode" field. +func ModelModeGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldModelMode, v)) +} + +// ModelModeGTE applies the GTE predicate on the "model_mode" field. +func ModelModeGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldModelMode, v)) +} + +// ModelModeLT applies the LT predicate on the "model_mode" field. +func ModelModeLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldModelMode, v)) +} + +// ModelModeLTE applies the LTE predicate on the "model_mode" field. +func ModelModeLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldModelMode, v)) +} + +// ModelModeIsNil applies the IsNil predicate on the "model_mode" field. +func ModelModeIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldModelMode)) +} + +// ModelModeNotNil applies the NotNil predicate on the "model_mode" field. +func ModelModeNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldModelMode)) +} + +// ModelCriticalEQ applies the EQ predicate on the "model_critical" field. +func ModelCriticalEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelCritical, v)) +} + +// ModelCriticalNEQ applies the NEQ predicate on the "model_critical" field. +func ModelCriticalNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldModelCritical, v)) +} + +// ModelCriticalIn applies the In predicate on the "model_critical" field. +func ModelCriticalIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldModelCritical, vs...)) +} + +// ModelCriticalNotIn applies the NotIn predicate on the "model_critical" field. +func ModelCriticalNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldModelCritical, vs...)) +} + +// ModelCriticalGT applies the GT predicate on the "model_critical" field. +func ModelCriticalGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldModelCritical, v)) +} + +// ModelCriticalGTE applies the GTE predicate on the "model_critical" field. +func ModelCriticalGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldModelCritical, v)) +} + +// ModelCriticalLT applies the LT predicate on the "model_critical" field. +func ModelCriticalLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldModelCritical, v)) +} + +// ModelCriticalLTE applies the LTE predicate on the "model_critical" field. +func ModelCriticalLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldModelCritical, v)) +} + +// ModelCriticalIsNil applies the IsNil predicate on the "model_critical" field. +func ModelCriticalIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldModelCritical)) +} + +// ModelCriticalNotNil applies the NotNil predicate on the "model_critical" field. +func ModelCriticalNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldModelCritical)) +} + +// ModelCriticalDEQ applies the EQ predicate on the "model_critical_d" field. +func ModelCriticalDEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldModelCriticalD, v)) +} + +// ModelCriticalDNEQ applies the NEQ predicate on the "model_critical_d" field. +func ModelCriticalDNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldModelCriticalD, v)) +} + +// ModelCriticalDIn applies the In predicate on the "model_critical_d" field. +func ModelCriticalDIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldModelCriticalD, vs...)) +} + +// ModelCriticalDNotIn applies the NotIn predicate on the "model_critical_d" field. +func ModelCriticalDNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldModelCriticalD, vs...)) +} + +// ModelCriticalDGT applies the GT predicate on the "model_critical_d" field. +func ModelCriticalDGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldModelCriticalD, v)) +} + +// ModelCriticalDGTE applies the GTE predicate on the "model_critical_d" field. +func ModelCriticalDGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldModelCriticalD, v)) +} + +// ModelCriticalDLT applies the LT predicate on the "model_critical_d" field. +func ModelCriticalDLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldModelCriticalD, v)) +} + +// ModelCriticalDLTE applies the LTE predicate on the "model_critical_d" field. +func ModelCriticalDLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldModelCriticalD, v)) +} + +// ModelCriticalDIsNil applies the IsNil predicate on the "model_critical_d" field. +func ModelCriticalDIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldModelCriticalD)) +} + +// ModelCriticalDNotNil applies the NotNil predicate on the "model_critical_d" field. +func ModelCriticalDNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldModelCriticalD)) +} + +// GameEQ applies the EQ predicate on the "game" field. +func GameEQ(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldGame, v)) +} + +// GameNEQ applies the NEQ predicate on the "game" field. +func GameNEQ(v bool) predicate.User { + return predicate.User(sql.FieldNEQ(FieldGame, v)) +} + +// GameIsNil applies the IsNil predicate on the "game" field. +func GameIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldGame)) +} + +// GameNotNil applies the NotNil predicate on the "game" field. +func GameNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldGame)) +} + +// GameTestEQ applies the EQ predicate on the "game_test" field. +func GameTestEQ(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldGameTest, v)) +} + +// GameTestNEQ applies the NEQ predicate on the "game_test" field. +func GameTestNEQ(v bool) predicate.User { + return predicate.User(sql.FieldNEQ(FieldGameTest, v)) +} + +// GameTestIsNil applies the IsNil predicate on the "game_test" field. +func GameTestIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldGameTest)) +} + +// GameTestNotNil applies the NotNil predicate on the "game_test" field. +func GameTestNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldGameTest)) +} + +// GameEndEQ applies the EQ predicate on the "game_end" field. +func GameEndEQ(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldGameEnd, v)) +} + +// GameEndNEQ applies the NEQ predicate on the "game_end" field. +func GameEndNEQ(v bool) predicate.User { + return predicate.User(sql.FieldNEQ(FieldGameEnd, v)) +} + +// GameEndIsNil applies the IsNil predicate on the "game_end" field. +func GameEndIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldGameEnd)) +} + +// GameEndNotNil applies the NotNil predicate on the "game_end" field. +func GameEndNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldGameEnd)) +} + +// GameAccountEQ applies the EQ predicate on the "game_account" field. +func GameAccountEQ(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldGameAccount, v)) +} + +// GameAccountNEQ applies the NEQ predicate on the "game_account" field. +func GameAccountNEQ(v bool) predicate.User { + return predicate.User(sql.FieldNEQ(FieldGameAccount, v)) +} + +// GameAccountIsNil applies the IsNil predicate on the "game_account" field. +func GameAccountIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldGameAccount)) +} + +// GameAccountNotNil applies the NotNil predicate on the "game_account" field. +func GameAccountNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldGameAccount)) +} + +// GameLvEQ applies the EQ predicate on the "game_lv" field. +func GameLvEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldGameLv, v)) +} + +// GameLvNEQ applies the NEQ predicate on the "game_lv" field. +func GameLvNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldGameLv, v)) +} + +// GameLvIn applies the In predicate on the "game_lv" field. +func GameLvIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldGameLv, vs...)) +} + +// GameLvNotIn applies the NotIn predicate on the "game_lv" field. +func GameLvNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldGameLv, vs...)) +} + +// GameLvGT applies the GT predicate on the "game_lv" field. +func GameLvGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldGameLv, v)) +} + +// GameLvGTE applies the GTE predicate on the "game_lv" field. +func GameLvGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldGameLv, v)) +} + +// GameLvLT applies the LT predicate on the "game_lv" field. +func GameLvLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldGameLv, v)) +} + +// GameLvLTE applies the LTE predicate on the "game_lv" field. +func GameLvLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldGameLv, v)) +} + +// GameLvIsNil applies the IsNil predicate on the "game_lv" field. +func GameLvIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldGameLv)) +} + +// GameLvNotNil applies the NotNil predicate on the "game_lv" field. +func GameLvNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldGameLv)) +} + // HasCard applies the HasEdge predicate on the "card" edge. func HasCard() predicate.User { return predicate.User(func(s *sql.Selector) { diff --git a/ent/user_create.go b/ent/user_create.go index db692da..e5f7f35 100644 --- a/ent/user_create.go +++ b/ent/user_create.go @@ -481,6 +481,188 @@ func (uc *UserCreate) SetNillableRoom(i *int) *UserCreate { return uc } +// SetModel sets the "model" field. +func (uc *UserCreate) SetModel(b bool) *UserCreate { + uc.mutation.SetModel(b) + return uc +} + +// SetNillableModel sets the "model" field if the given value is not nil. +func (uc *UserCreate) SetNillableModel(b *bool) *UserCreate { + if b != nil { + uc.SetModel(*b) + } + return uc +} + +// SetModelAt sets the "model_at" field. +func (uc *UserCreate) SetModelAt(t time.Time) *UserCreate { + uc.mutation.SetModelAt(t) + return uc +} + +// SetNillableModelAt sets the "model_at" field if the given value is not nil. +func (uc *UserCreate) SetNillableModelAt(t *time.Time) *UserCreate { + if t != nil { + uc.SetModelAt(*t) + } + return uc +} + +// SetModelAttack sets the "model_attack" field. +func (uc *UserCreate) SetModelAttack(i int) *UserCreate { + uc.mutation.SetModelAttack(i) + return uc +} + +// SetNillableModelAttack sets the "model_attack" field if the given value is not nil. +func (uc *UserCreate) SetNillableModelAttack(i *int) *UserCreate { + if i != nil { + uc.SetModelAttack(*i) + } + return uc +} + +// SetModelLimit sets the "model_limit" field. +func (uc *UserCreate) SetModelLimit(i int) *UserCreate { + uc.mutation.SetModelLimit(i) + return uc +} + +// SetNillableModelLimit sets the "model_limit" field if the given value is not nil. +func (uc *UserCreate) SetNillableModelLimit(i *int) *UserCreate { + if i != nil { + uc.SetModelLimit(*i) + } + return uc +} + +// SetModelSkill sets the "model_skill" field. +func (uc *UserCreate) SetModelSkill(i int) *UserCreate { + uc.mutation.SetModelSkill(i) + return uc +} + +// SetNillableModelSkill sets the "model_skill" field if the given value is not nil. +func (uc *UserCreate) SetNillableModelSkill(i *int) *UserCreate { + if i != nil { + uc.SetModelSkill(*i) + } + return uc +} + +// SetModelMode sets the "model_mode" field. +func (uc *UserCreate) SetModelMode(i int) *UserCreate { + uc.mutation.SetModelMode(i) + return uc +} + +// SetNillableModelMode sets the "model_mode" field if the given value is not nil. +func (uc *UserCreate) SetNillableModelMode(i *int) *UserCreate { + if i != nil { + uc.SetModelMode(*i) + } + return uc +} + +// SetModelCritical sets the "model_critical" field. +func (uc *UserCreate) SetModelCritical(i int) *UserCreate { + uc.mutation.SetModelCritical(i) + return uc +} + +// SetNillableModelCritical sets the "model_critical" field if the given value is not nil. +func (uc *UserCreate) SetNillableModelCritical(i *int) *UserCreate { + if i != nil { + uc.SetModelCritical(*i) + } + return uc +} + +// SetModelCriticalD sets the "model_critical_d" field. +func (uc *UserCreate) SetModelCriticalD(i int) *UserCreate { + uc.mutation.SetModelCriticalD(i) + return uc +} + +// SetNillableModelCriticalD sets the "model_critical_d" field if the given value is not nil. +func (uc *UserCreate) SetNillableModelCriticalD(i *int) *UserCreate { + if i != nil { + uc.SetModelCriticalD(*i) + } + return uc +} + +// SetGame sets the "game" field. +func (uc *UserCreate) SetGame(b bool) *UserCreate { + uc.mutation.SetGame(b) + return uc +} + +// SetNillableGame sets the "game" field if the given value is not nil. +func (uc *UserCreate) SetNillableGame(b *bool) *UserCreate { + if b != nil { + uc.SetGame(*b) + } + return uc +} + +// SetGameTest sets the "game_test" field. +func (uc *UserCreate) SetGameTest(b bool) *UserCreate { + uc.mutation.SetGameTest(b) + return uc +} + +// SetNillableGameTest sets the "game_test" field if the given value is not nil. +func (uc *UserCreate) SetNillableGameTest(b *bool) *UserCreate { + if b != nil { + uc.SetGameTest(*b) + } + return uc +} + +// SetGameEnd sets the "game_end" field. +func (uc *UserCreate) SetGameEnd(b bool) *UserCreate { + uc.mutation.SetGameEnd(b) + return uc +} + +// SetNillableGameEnd sets the "game_end" field if the given value is not nil. +func (uc *UserCreate) SetNillableGameEnd(b *bool) *UserCreate { + if b != nil { + uc.SetGameEnd(*b) + } + return uc +} + +// SetGameAccount sets the "game_account" field. +func (uc *UserCreate) SetGameAccount(b bool) *UserCreate { + uc.mutation.SetGameAccount(b) + return uc +} + +// SetNillableGameAccount sets the "game_account" field if the given value is not nil. +func (uc *UserCreate) SetNillableGameAccount(b *bool) *UserCreate { + if b != nil { + uc.SetGameAccount(*b) + } + return uc +} + +// SetGameLv sets the "game_lv" field. +func (uc *UserCreate) SetGameLv(i int) *UserCreate { + uc.mutation.SetGameLv(i) + return uc +} + +// SetNillableGameLv sets the "game_lv" field if the given value is not nil. +func (uc *UserCreate) SetNillableGameLv(i *int) *UserCreate { + if i != nil { + uc.SetGameLv(*i) + } + return uc +} + // AddCardIDs adds the "card" edge to the Card entity by IDs. func (uc *UserCreate) AddCardIDs(ids ...int) *UserCreate { uc.mutation.AddCardIDs(ids...) @@ -599,6 +781,26 @@ func (uc *UserCreate) defaults() { v := user.DefaultNext uc.mutation.SetNext(v) } + if _, ok := uc.mutation.ModelAt(); !ok { + v := user.DefaultModelAt() + uc.mutation.SetModelAt(v) + } + if _, ok := uc.mutation.Game(); !ok { + v := user.DefaultGame + uc.mutation.SetGame(v) + } + if _, ok := uc.mutation.GameTest(); !ok { + v := user.DefaultGameTest + uc.mutation.SetGameTest(v) + } + if _, ok := uc.mutation.GameEnd(); !ok { + v := user.DefaultGameEnd + uc.mutation.SetGameEnd(v) + } + if _, ok := uc.mutation.GameAccount(); !ok { + v := user.DefaultGameAccount + uc.mutation.SetGameAccount(v) + } } // check runs all checks and user-defined validators on the builder. @@ -781,6 +983,58 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { _spec.SetField(user.FieldRoom, field.TypeInt, value) _node.Room = value } + if value, ok := uc.mutation.Model(); ok { + _spec.SetField(user.FieldModel, field.TypeBool, value) + _node.Model = value + } + if value, ok := uc.mutation.ModelAt(); ok { + _spec.SetField(user.FieldModelAt, field.TypeTime, value) + _node.ModelAt = value + } + if value, ok := uc.mutation.ModelAttack(); ok { + _spec.SetField(user.FieldModelAttack, field.TypeInt, value) + _node.ModelAttack = value + } + if value, ok := uc.mutation.ModelLimit(); ok { + _spec.SetField(user.FieldModelLimit, field.TypeInt, value) + _node.ModelLimit = value + } + if value, ok := uc.mutation.ModelSkill(); ok { + _spec.SetField(user.FieldModelSkill, field.TypeInt, value) + _node.ModelSkill = value + } + if value, ok := uc.mutation.ModelMode(); ok { + _spec.SetField(user.FieldModelMode, field.TypeInt, value) + _node.ModelMode = value + } + if value, ok := uc.mutation.ModelCritical(); ok { + _spec.SetField(user.FieldModelCritical, field.TypeInt, value) + _node.ModelCritical = value + } + if value, ok := uc.mutation.ModelCriticalD(); ok { + _spec.SetField(user.FieldModelCriticalD, field.TypeInt, value) + _node.ModelCriticalD = value + } + if value, ok := uc.mutation.Game(); ok { + _spec.SetField(user.FieldGame, field.TypeBool, value) + _node.Game = value + } + if value, ok := uc.mutation.GameTest(); ok { + _spec.SetField(user.FieldGameTest, field.TypeBool, value) + _node.GameTest = value + } + if value, ok := uc.mutation.GameEnd(); ok { + _spec.SetField(user.FieldGameEnd, field.TypeBool, value) + _node.GameEnd = value + } + if value, ok := uc.mutation.GameAccount(); ok { + _spec.SetField(user.FieldGameAccount, field.TypeBool, value) + _node.GameAccount = value + } + if value, ok := uc.mutation.GameLv(); ok { + _spec.SetField(user.FieldGameLv, field.TypeInt, value) + _node.GameLv = value + } if nodes := uc.mutation.CardIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, diff --git a/ent/user_update.go b/ent/user_update.go index ee602d3..fa0d678 100644 --- a/ent/user_update.go +++ b/ent/user_update.go @@ -705,6 +705,315 @@ func (uu *UserUpdate) ClearRoom() *UserUpdate { return uu } +// SetModel sets the "model" field. +func (uu *UserUpdate) SetModel(b bool) *UserUpdate { + uu.mutation.SetModel(b) + return uu +} + +// SetNillableModel sets the "model" field if the given value is not nil. +func (uu *UserUpdate) SetNillableModel(b *bool) *UserUpdate { + if b != nil { + uu.SetModel(*b) + } + return uu +} + +// ClearModel clears the value of the "model" field. +func (uu *UserUpdate) ClearModel() *UserUpdate { + uu.mutation.ClearModel() + return uu +} + +// SetModelAt sets the "model_at" field. +func (uu *UserUpdate) SetModelAt(t time.Time) *UserUpdate { + uu.mutation.SetModelAt(t) + return uu +} + +// SetNillableModelAt sets the "model_at" field if the given value is not nil. +func (uu *UserUpdate) SetNillableModelAt(t *time.Time) *UserUpdate { + if t != nil { + uu.SetModelAt(*t) + } + return uu +} + +// ClearModelAt clears the value of the "model_at" field. +func (uu *UserUpdate) ClearModelAt() *UserUpdate { + uu.mutation.ClearModelAt() + return uu +} + +// SetModelAttack sets the "model_attack" field. +func (uu *UserUpdate) SetModelAttack(i int) *UserUpdate { + uu.mutation.ResetModelAttack() + uu.mutation.SetModelAttack(i) + return uu +} + +// SetNillableModelAttack sets the "model_attack" field if the given value is not nil. +func (uu *UserUpdate) SetNillableModelAttack(i *int) *UserUpdate { + if i != nil { + uu.SetModelAttack(*i) + } + return uu +} + +// AddModelAttack adds i to the "model_attack" field. +func (uu *UserUpdate) AddModelAttack(i int) *UserUpdate { + uu.mutation.AddModelAttack(i) + return uu +} + +// ClearModelAttack clears the value of the "model_attack" field. +func (uu *UserUpdate) ClearModelAttack() *UserUpdate { + uu.mutation.ClearModelAttack() + return uu +} + +// SetModelLimit sets the "model_limit" field. +func (uu *UserUpdate) SetModelLimit(i int) *UserUpdate { + uu.mutation.ResetModelLimit() + uu.mutation.SetModelLimit(i) + return uu +} + +// SetNillableModelLimit sets the "model_limit" field if the given value is not nil. +func (uu *UserUpdate) SetNillableModelLimit(i *int) *UserUpdate { + if i != nil { + uu.SetModelLimit(*i) + } + return uu +} + +// AddModelLimit adds i to the "model_limit" field. +func (uu *UserUpdate) AddModelLimit(i int) *UserUpdate { + uu.mutation.AddModelLimit(i) + return uu +} + +// ClearModelLimit clears the value of the "model_limit" field. +func (uu *UserUpdate) ClearModelLimit() *UserUpdate { + uu.mutation.ClearModelLimit() + return uu +} + +// SetModelSkill sets the "model_skill" field. +func (uu *UserUpdate) SetModelSkill(i int) *UserUpdate { + uu.mutation.ResetModelSkill() + uu.mutation.SetModelSkill(i) + return uu +} + +// SetNillableModelSkill sets the "model_skill" field if the given value is not nil. +func (uu *UserUpdate) SetNillableModelSkill(i *int) *UserUpdate { + if i != nil { + uu.SetModelSkill(*i) + } + return uu +} + +// AddModelSkill adds i to the "model_skill" field. +func (uu *UserUpdate) AddModelSkill(i int) *UserUpdate { + uu.mutation.AddModelSkill(i) + return uu +} + +// ClearModelSkill clears the value of the "model_skill" field. +func (uu *UserUpdate) ClearModelSkill() *UserUpdate { + uu.mutation.ClearModelSkill() + return uu +} + +// SetModelMode sets the "model_mode" field. +func (uu *UserUpdate) SetModelMode(i int) *UserUpdate { + uu.mutation.ResetModelMode() + uu.mutation.SetModelMode(i) + return uu +} + +// SetNillableModelMode sets the "model_mode" field if the given value is not nil. +func (uu *UserUpdate) SetNillableModelMode(i *int) *UserUpdate { + if i != nil { + uu.SetModelMode(*i) + } + return uu +} + +// AddModelMode adds i to the "model_mode" field. +func (uu *UserUpdate) AddModelMode(i int) *UserUpdate { + uu.mutation.AddModelMode(i) + return uu +} + +// ClearModelMode clears the value of the "model_mode" field. +func (uu *UserUpdate) ClearModelMode() *UserUpdate { + uu.mutation.ClearModelMode() + return uu +} + +// SetModelCritical sets the "model_critical" field. +func (uu *UserUpdate) SetModelCritical(i int) *UserUpdate { + uu.mutation.ResetModelCritical() + uu.mutation.SetModelCritical(i) + return uu +} + +// SetNillableModelCritical sets the "model_critical" field if the given value is not nil. +func (uu *UserUpdate) SetNillableModelCritical(i *int) *UserUpdate { + if i != nil { + uu.SetModelCritical(*i) + } + return uu +} + +// AddModelCritical adds i to the "model_critical" field. +func (uu *UserUpdate) AddModelCritical(i int) *UserUpdate { + uu.mutation.AddModelCritical(i) + return uu +} + +// ClearModelCritical clears the value of the "model_critical" field. +func (uu *UserUpdate) ClearModelCritical() *UserUpdate { + uu.mutation.ClearModelCritical() + return uu +} + +// SetModelCriticalD sets the "model_critical_d" field. +func (uu *UserUpdate) SetModelCriticalD(i int) *UserUpdate { + uu.mutation.ResetModelCriticalD() + uu.mutation.SetModelCriticalD(i) + return uu +} + +// SetNillableModelCriticalD sets the "model_critical_d" field if the given value is not nil. +func (uu *UserUpdate) SetNillableModelCriticalD(i *int) *UserUpdate { + if i != nil { + uu.SetModelCriticalD(*i) + } + return uu +} + +// AddModelCriticalD adds i to the "model_critical_d" field. +func (uu *UserUpdate) AddModelCriticalD(i int) *UserUpdate { + uu.mutation.AddModelCriticalD(i) + return uu +} + +// ClearModelCriticalD clears the value of the "model_critical_d" field. +func (uu *UserUpdate) ClearModelCriticalD() *UserUpdate { + uu.mutation.ClearModelCriticalD() + return uu +} + +// SetGame sets the "game" field. +func (uu *UserUpdate) SetGame(b bool) *UserUpdate { + uu.mutation.SetGame(b) + return uu +} + +// SetNillableGame sets the "game" field if the given value is not nil. +func (uu *UserUpdate) SetNillableGame(b *bool) *UserUpdate { + if b != nil { + uu.SetGame(*b) + } + return uu +} + +// ClearGame clears the value of the "game" field. +func (uu *UserUpdate) ClearGame() *UserUpdate { + uu.mutation.ClearGame() + return uu +} + +// SetGameTest sets the "game_test" field. +func (uu *UserUpdate) SetGameTest(b bool) *UserUpdate { + uu.mutation.SetGameTest(b) + return uu +} + +// SetNillableGameTest sets the "game_test" field if the given value is not nil. +func (uu *UserUpdate) SetNillableGameTest(b *bool) *UserUpdate { + if b != nil { + uu.SetGameTest(*b) + } + return uu +} + +// ClearGameTest clears the value of the "game_test" field. +func (uu *UserUpdate) ClearGameTest() *UserUpdate { + uu.mutation.ClearGameTest() + return uu +} + +// SetGameEnd sets the "game_end" field. +func (uu *UserUpdate) SetGameEnd(b bool) *UserUpdate { + uu.mutation.SetGameEnd(b) + return uu +} + +// SetNillableGameEnd sets the "game_end" field if the given value is not nil. +func (uu *UserUpdate) SetNillableGameEnd(b *bool) *UserUpdate { + if b != nil { + uu.SetGameEnd(*b) + } + return uu +} + +// ClearGameEnd clears the value of the "game_end" field. +func (uu *UserUpdate) ClearGameEnd() *UserUpdate { + uu.mutation.ClearGameEnd() + return uu +} + +// SetGameAccount sets the "game_account" field. +func (uu *UserUpdate) SetGameAccount(b bool) *UserUpdate { + uu.mutation.SetGameAccount(b) + return uu +} + +// SetNillableGameAccount sets the "game_account" field if the given value is not nil. +func (uu *UserUpdate) SetNillableGameAccount(b *bool) *UserUpdate { + if b != nil { + uu.SetGameAccount(*b) + } + return uu +} + +// ClearGameAccount clears the value of the "game_account" field. +func (uu *UserUpdate) ClearGameAccount() *UserUpdate { + uu.mutation.ClearGameAccount() + return uu +} + +// SetGameLv sets the "game_lv" field. +func (uu *UserUpdate) SetGameLv(i int) *UserUpdate { + uu.mutation.ResetGameLv() + uu.mutation.SetGameLv(i) + return uu +} + +// SetNillableGameLv sets the "game_lv" field if the given value is not nil. +func (uu *UserUpdate) SetNillableGameLv(i *int) *UserUpdate { + if i != nil { + uu.SetGameLv(*i) + } + return uu +} + +// AddGameLv adds i to the "game_lv" field. +func (uu *UserUpdate) AddGameLv(i int) *UserUpdate { + uu.mutation.AddGameLv(i) + return uu +} + +// ClearGameLv clears the value of the "game_lv" field. +func (uu *UserUpdate) ClearGameLv() *UserUpdate { + uu.mutation.ClearGameLv() + return uu +} + // AddCardIDs adds the "card" edge to the Card entity by IDs. func (uu *UserUpdate) AddCardIDs(ids ...int) *UserUpdate { uu.mutation.AddCardIDs(ids...) @@ -995,6 +1304,105 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { if uu.mutation.RoomCleared() { _spec.ClearField(user.FieldRoom, field.TypeInt) } + if value, ok := uu.mutation.Model(); ok { + _spec.SetField(user.FieldModel, field.TypeBool, value) + } + if uu.mutation.ModelCleared() { + _spec.ClearField(user.FieldModel, field.TypeBool) + } + if value, ok := uu.mutation.ModelAt(); ok { + _spec.SetField(user.FieldModelAt, field.TypeTime, value) + } + if uu.mutation.ModelAtCleared() { + _spec.ClearField(user.FieldModelAt, field.TypeTime) + } + if value, ok := uu.mutation.ModelAttack(); ok { + _spec.SetField(user.FieldModelAttack, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedModelAttack(); ok { + _spec.AddField(user.FieldModelAttack, field.TypeInt, value) + } + if uu.mutation.ModelAttackCleared() { + _spec.ClearField(user.FieldModelAttack, field.TypeInt) + } + if value, ok := uu.mutation.ModelLimit(); ok { + _spec.SetField(user.FieldModelLimit, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedModelLimit(); ok { + _spec.AddField(user.FieldModelLimit, field.TypeInt, value) + } + if uu.mutation.ModelLimitCleared() { + _spec.ClearField(user.FieldModelLimit, field.TypeInt) + } + if value, ok := uu.mutation.ModelSkill(); ok { + _spec.SetField(user.FieldModelSkill, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedModelSkill(); ok { + _spec.AddField(user.FieldModelSkill, field.TypeInt, value) + } + if uu.mutation.ModelSkillCleared() { + _spec.ClearField(user.FieldModelSkill, field.TypeInt) + } + if value, ok := uu.mutation.ModelMode(); ok { + _spec.SetField(user.FieldModelMode, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedModelMode(); ok { + _spec.AddField(user.FieldModelMode, field.TypeInt, value) + } + if uu.mutation.ModelModeCleared() { + _spec.ClearField(user.FieldModelMode, field.TypeInt) + } + if value, ok := uu.mutation.ModelCritical(); ok { + _spec.SetField(user.FieldModelCritical, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedModelCritical(); ok { + _spec.AddField(user.FieldModelCritical, field.TypeInt, value) + } + if uu.mutation.ModelCriticalCleared() { + _spec.ClearField(user.FieldModelCritical, field.TypeInt) + } + if value, ok := uu.mutation.ModelCriticalD(); ok { + _spec.SetField(user.FieldModelCriticalD, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedModelCriticalD(); ok { + _spec.AddField(user.FieldModelCriticalD, field.TypeInt, value) + } + if uu.mutation.ModelCriticalDCleared() { + _spec.ClearField(user.FieldModelCriticalD, field.TypeInt) + } + if value, ok := uu.mutation.Game(); ok { + _spec.SetField(user.FieldGame, field.TypeBool, value) + } + if uu.mutation.GameCleared() { + _spec.ClearField(user.FieldGame, field.TypeBool) + } + if value, ok := uu.mutation.GameTest(); ok { + _spec.SetField(user.FieldGameTest, field.TypeBool, value) + } + if uu.mutation.GameTestCleared() { + _spec.ClearField(user.FieldGameTest, field.TypeBool) + } + if value, ok := uu.mutation.GameEnd(); ok { + _spec.SetField(user.FieldGameEnd, field.TypeBool, value) + } + if uu.mutation.GameEndCleared() { + _spec.ClearField(user.FieldGameEnd, field.TypeBool) + } + if value, ok := uu.mutation.GameAccount(); ok { + _spec.SetField(user.FieldGameAccount, field.TypeBool, value) + } + if uu.mutation.GameAccountCleared() { + _spec.ClearField(user.FieldGameAccount, field.TypeBool) + } + if value, ok := uu.mutation.GameLv(); ok { + _spec.SetField(user.FieldGameLv, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedGameLv(); ok { + _spec.AddField(user.FieldGameLv, field.TypeInt, value) + } + if uu.mutation.GameLvCleared() { + _spec.ClearField(user.FieldGameLv, field.TypeInt) + } if uu.mutation.CardCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, @@ -1736,6 +2144,315 @@ func (uuo *UserUpdateOne) ClearRoom() *UserUpdateOne { return uuo } +// SetModel sets the "model" field. +func (uuo *UserUpdateOne) SetModel(b bool) *UserUpdateOne { + uuo.mutation.SetModel(b) + return uuo +} + +// SetNillableModel sets the "model" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableModel(b *bool) *UserUpdateOne { + if b != nil { + uuo.SetModel(*b) + } + return uuo +} + +// ClearModel clears the value of the "model" field. +func (uuo *UserUpdateOne) ClearModel() *UserUpdateOne { + uuo.mutation.ClearModel() + return uuo +} + +// SetModelAt sets the "model_at" field. +func (uuo *UserUpdateOne) SetModelAt(t time.Time) *UserUpdateOne { + uuo.mutation.SetModelAt(t) + return uuo +} + +// SetNillableModelAt sets the "model_at" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableModelAt(t *time.Time) *UserUpdateOne { + if t != nil { + uuo.SetModelAt(*t) + } + return uuo +} + +// ClearModelAt clears the value of the "model_at" field. +func (uuo *UserUpdateOne) ClearModelAt() *UserUpdateOne { + uuo.mutation.ClearModelAt() + return uuo +} + +// SetModelAttack sets the "model_attack" field. +func (uuo *UserUpdateOne) SetModelAttack(i int) *UserUpdateOne { + uuo.mutation.ResetModelAttack() + uuo.mutation.SetModelAttack(i) + return uuo +} + +// SetNillableModelAttack sets the "model_attack" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableModelAttack(i *int) *UserUpdateOne { + if i != nil { + uuo.SetModelAttack(*i) + } + return uuo +} + +// AddModelAttack adds i to the "model_attack" field. +func (uuo *UserUpdateOne) AddModelAttack(i int) *UserUpdateOne { + uuo.mutation.AddModelAttack(i) + return uuo +} + +// ClearModelAttack clears the value of the "model_attack" field. +func (uuo *UserUpdateOne) ClearModelAttack() *UserUpdateOne { + uuo.mutation.ClearModelAttack() + return uuo +} + +// SetModelLimit sets the "model_limit" field. +func (uuo *UserUpdateOne) SetModelLimit(i int) *UserUpdateOne { + uuo.mutation.ResetModelLimit() + uuo.mutation.SetModelLimit(i) + return uuo +} + +// SetNillableModelLimit sets the "model_limit" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableModelLimit(i *int) *UserUpdateOne { + if i != nil { + uuo.SetModelLimit(*i) + } + return uuo +} + +// AddModelLimit adds i to the "model_limit" field. +func (uuo *UserUpdateOne) AddModelLimit(i int) *UserUpdateOne { + uuo.mutation.AddModelLimit(i) + return uuo +} + +// ClearModelLimit clears the value of the "model_limit" field. +func (uuo *UserUpdateOne) ClearModelLimit() *UserUpdateOne { + uuo.mutation.ClearModelLimit() + return uuo +} + +// SetModelSkill sets the "model_skill" field. +func (uuo *UserUpdateOne) SetModelSkill(i int) *UserUpdateOne { + uuo.mutation.ResetModelSkill() + uuo.mutation.SetModelSkill(i) + return uuo +} + +// SetNillableModelSkill sets the "model_skill" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableModelSkill(i *int) *UserUpdateOne { + if i != nil { + uuo.SetModelSkill(*i) + } + return uuo +} + +// AddModelSkill adds i to the "model_skill" field. +func (uuo *UserUpdateOne) AddModelSkill(i int) *UserUpdateOne { + uuo.mutation.AddModelSkill(i) + return uuo +} + +// ClearModelSkill clears the value of the "model_skill" field. +func (uuo *UserUpdateOne) ClearModelSkill() *UserUpdateOne { + uuo.mutation.ClearModelSkill() + return uuo +} + +// SetModelMode sets the "model_mode" field. +func (uuo *UserUpdateOne) SetModelMode(i int) *UserUpdateOne { + uuo.mutation.ResetModelMode() + uuo.mutation.SetModelMode(i) + return uuo +} + +// SetNillableModelMode sets the "model_mode" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableModelMode(i *int) *UserUpdateOne { + if i != nil { + uuo.SetModelMode(*i) + } + return uuo +} + +// AddModelMode adds i to the "model_mode" field. +func (uuo *UserUpdateOne) AddModelMode(i int) *UserUpdateOne { + uuo.mutation.AddModelMode(i) + return uuo +} + +// ClearModelMode clears the value of the "model_mode" field. +func (uuo *UserUpdateOne) ClearModelMode() *UserUpdateOne { + uuo.mutation.ClearModelMode() + return uuo +} + +// SetModelCritical sets the "model_critical" field. +func (uuo *UserUpdateOne) SetModelCritical(i int) *UserUpdateOne { + uuo.mutation.ResetModelCritical() + uuo.mutation.SetModelCritical(i) + return uuo +} + +// SetNillableModelCritical sets the "model_critical" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableModelCritical(i *int) *UserUpdateOne { + if i != nil { + uuo.SetModelCritical(*i) + } + return uuo +} + +// AddModelCritical adds i to the "model_critical" field. +func (uuo *UserUpdateOne) AddModelCritical(i int) *UserUpdateOne { + uuo.mutation.AddModelCritical(i) + return uuo +} + +// ClearModelCritical clears the value of the "model_critical" field. +func (uuo *UserUpdateOne) ClearModelCritical() *UserUpdateOne { + uuo.mutation.ClearModelCritical() + return uuo +} + +// SetModelCriticalD sets the "model_critical_d" field. +func (uuo *UserUpdateOne) SetModelCriticalD(i int) *UserUpdateOne { + uuo.mutation.ResetModelCriticalD() + uuo.mutation.SetModelCriticalD(i) + return uuo +} + +// SetNillableModelCriticalD sets the "model_critical_d" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableModelCriticalD(i *int) *UserUpdateOne { + if i != nil { + uuo.SetModelCriticalD(*i) + } + return uuo +} + +// AddModelCriticalD adds i to the "model_critical_d" field. +func (uuo *UserUpdateOne) AddModelCriticalD(i int) *UserUpdateOne { + uuo.mutation.AddModelCriticalD(i) + return uuo +} + +// ClearModelCriticalD clears the value of the "model_critical_d" field. +func (uuo *UserUpdateOne) ClearModelCriticalD() *UserUpdateOne { + uuo.mutation.ClearModelCriticalD() + return uuo +} + +// SetGame sets the "game" field. +func (uuo *UserUpdateOne) SetGame(b bool) *UserUpdateOne { + uuo.mutation.SetGame(b) + return uuo +} + +// SetNillableGame sets the "game" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableGame(b *bool) *UserUpdateOne { + if b != nil { + uuo.SetGame(*b) + } + return uuo +} + +// ClearGame clears the value of the "game" field. +func (uuo *UserUpdateOne) ClearGame() *UserUpdateOne { + uuo.mutation.ClearGame() + return uuo +} + +// SetGameTest sets the "game_test" field. +func (uuo *UserUpdateOne) SetGameTest(b bool) *UserUpdateOne { + uuo.mutation.SetGameTest(b) + return uuo +} + +// SetNillableGameTest sets the "game_test" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableGameTest(b *bool) *UserUpdateOne { + if b != nil { + uuo.SetGameTest(*b) + } + return uuo +} + +// ClearGameTest clears the value of the "game_test" field. +func (uuo *UserUpdateOne) ClearGameTest() *UserUpdateOne { + uuo.mutation.ClearGameTest() + return uuo +} + +// SetGameEnd sets the "game_end" field. +func (uuo *UserUpdateOne) SetGameEnd(b bool) *UserUpdateOne { + uuo.mutation.SetGameEnd(b) + return uuo +} + +// SetNillableGameEnd sets the "game_end" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableGameEnd(b *bool) *UserUpdateOne { + if b != nil { + uuo.SetGameEnd(*b) + } + return uuo +} + +// ClearGameEnd clears the value of the "game_end" field. +func (uuo *UserUpdateOne) ClearGameEnd() *UserUpdateOne { + uuo.mutation.ClearGameEnd() + return uuo +} + +// SetGameAccount sets the "game_account" field. +func (uuo *UserUpdateOne) SetGameAccount(b bool) *UserUpdateOne { + uuo.mutation.SetGameAccount(b) + return uuo +} + +// SetNillableGameAccount sets the "game_account" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableGameAccount(b *bool) *UserUpdateOne { + if b != nil { + uuo.SetGameAccount(*b) + } + return uuo +} + +// ClearGameAccount clears the value of the "game_account" field. +func (uuo *UserUpdateOne) ClearGameAccount() *UserUpdateOne { + uuo.mutation.ClearGameAccount() + return uuo +} + +// SetGameLv sets the "game_lv" field. +func (uuo *UserUpdateOne) SetGameLv(i int) *UserUpdateOne { + uuo.mutation.ResetGameLv() + uuo.mutation.SetGameLv(i) + return uuo +} + +// SetNillableGameLv sets the "game_lv" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableGameLv(i *int) *UserUpdateOne { + if i != nil { + uuo.SetGameLv(*i) + } + return uuo +} + +// AddGameLv adds i to the "game_lv" field. +func (uuo *UserUpdateOne) AddGameLv(i int) *UserUpdateOne { + uuo.mutation.AddGameLv(i) + return uuo +} + +// ClearGameLv clears the value of the "game_lv" field. +func (uuo *UserUpdateOne) ClearGameLv() *UserUpdateOne { + uuo.mutation.ClearGameLv() + return uuo +} + // AddCardIDs adds the "card" edge to the Card entity by IDs. func (uuo *UserUpdateOne) AddCardIDs(ids ...int) *UserUpdateOne { uuo.mutation.AddCardIDs(ids...) @@ -2056,6 +2773,105 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) if uuo.mutation.RoomCleared() { _spec.ClearField(user.FieldRoom, field.TypeInt) } + if value, ok := uuo.mutation.Model(); ok { + _spec.SetField(user.FieldModel, field.TypeBool, value) + } + if uuo.mutation.ModelCleared() { + _spec.ClearField(user.FieldModel, field.TypeBool) + } + if value, ok := uuo.mutation.ModelAt(); ok { + _spec.SetField(user.FieldModelAt, field.TypeTime, value) + } + if uuo.mutation.ModelAtCleared() { + _spec.ClearField(user.FieldModelAt, field.TypeTime) + } + if value, ok := uuo.mutation.ModelAttack(); ok { + _spec.SetField(user.FieldModelAttack, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedModelAttack(); ok { + _spec.AddField(user.FieldModelAttack, field.TypeInt, value) + } + if uuo.mutation.ModelAttackCleared() { + _spec.ClearField(user.FieldModelAttack, field.TypeInt) + } + if value, ok := uuo.mutation.ModelLimit(); ok { + _spec.SetField(user.FieldModelLimit, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedModelLimit(); ok { + _spec.AddField(user.FieldModelLimit, field.TypeInt, value) + } + if uuo.mutation.ModelLimitCleared() { + _spec.ClearField(user.FieldModelLimit, field.TypeInt) + } + if value, ok := uuo.mutation.ModelSkill(); ok { + _spec.SetField(user.FieldModelSkill, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedModelSkill(); ok { + _spec.AddField(user.FieldModelSkill, field.TypeInt, value) + } + if uuo.mutation.ModelSkillCleared() { + _spec.ClearField(user.FieldModelSkill, field.TypeInt) + } + if value, ok := uuo.mutation.ModelMode(); ok { + _spec.SetField(user.FieldModelMode, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedModelMode(); ok { + _spec.AddField(user.FieldModelMode, field.TypeInt, value) + } + if uuo.mutation.ModelModeCleared() { + _spec.ClearField(user.FieldModelMode, field.TypeInt) + } + if value, ok := uuo.mutation.ModelCritical(); ok { + _spec.SetField(user.FieldModelCritical, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedModelCritical(); ok { + _spec.AddField(user.FieldModelCritical, field.TypeInt, value) + } + if uuo.mutation.ModelCriticalCleared() { + _spec.ClearField(user.FieldModelCritical, field.TypeInt) + } + if value, ok := uuo.mutation.ModelCriticalD(); ok { + _spec.SetField(user.FieldModelCriticalD, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedModelCriticalD(); ok { + _spec.AddField(user.FieldModelCriticalD, field.TypeInt, value) + } + if uuo.mutation.ModelCriticalDCleared() { + _spec.ClearField(user.FieldModelCriticalD, field.TypeInt) + } + if value, ok := uuo.mutation.Game(); ok { + _spec.SetField(user.FieldGame, field.TypeBool, value) + } + if uuo.mutation.GameCleared() { + _spec.ClearField(user.FieldGame, field.TypeBool) + } + if value, ok := uuo.mutation.GameTest(); ok { + _spec.SetField(user.FieldGameTest, field.TypeBool, value) + } + if uuo.mutation.GameTestCleared() { + _spec.ClearField(user.FieldGameTest, field.TypeBool) + } + if value, ok := uuo.mutation.GameEnd(); ok { + _spec.SetField(user.FieldGameEnd, field.TypeBool, value) + } + if uuo.mutation.GameEndCleared() { + _spec.ClearField(user.FieldGameEnd, field.TypeBool) + } + if value, ok := uuo.mutation.GameAccount(); ok { + _spec.SetField(user.FieldGameAccount, field.TypeBool, value) + } + if uuo.mutation.GameAccountCleared() { + _spec.ClearField(user.FieldGameAccount, field.TypeBool) + } + if value, ok := uuo.mutation.GameLv(); ok { + _spec.SetField(user.FieldGameLv, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedGameLv(); ok { + _spec.AddField(user.FieldGameLv, field.TypeInt, value) + } + if uuo.mutation.GameLvCleared() { + _spec.ClearField(user.FieldGameLv, field.TypeInt) + } if uuo.mutation.CardCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, diff --git a/tmp/card_account_change_fix.zsh b/tmp/card_account_change_fix.zsh new file mode 100755 index 0000000..cf84ada --- /dev/null +++ b/tmp/card_account_change_fix.zsh @@ -0,0 +1,21 @@ +#!/bin/zsh +host=https://api.syui.ai +token=`cat ~/.config/atr/api_card.json|jq -r .token` +pass=`cat ~/.config/atr/api_card.json|jq -r .password` +if [ -z "$1" ];then + exit +fi +if [ -z "$2" ];then + did=`curl -sL "$host/users?itemsPerPage=2000"|jq ".[]|select(.did == \"$1\")"|jq -r .id` + echo $did + exit +fi + +echo old-id new-id +read + +echo account delete $1 token +curl -X PATCH -H "Content-Type: application/json" -d "{\"delete\":true,\"token\":\"$token\"}" -s $host/users/$1 + +echo account refresh $2 token +curl -X PATCH -H "Content-Type: application/json" -d "{\"delete\":false,\"token\":\"$token\"}" -s $host/users/$2 diff --git a/tmp/card_account_delete.zsh b/tmp/card_account_delete.zsh index adab758..e8548b6 100755 --- a/tmp/card_account_delete.zsh +++ b/tmp/card_account_delete.zsh @@ -8,5 +8,12 @@ if [ -z "$1" ];then fi id=$1 -curl -X PATCH -H "Content-Type: application/json" -d "{\"delete\":true,\"token\":\"$token\"}" -s $host/users/$id +s=$2 +if [ -n "$2" ];then + s=$2 +else + s=true +fi + +curl -X PATCH -H "Content-Type: application/json" -d "{\"delete\":$s,\"token\":\"$token\"}" -s $host/users/$id diff --git a/tmp/card_add_16.zsh b/tmp/card_add_16.zsh index 5e010cf..83e7c7c 100755 --- a/tmp/card_add_16.zsh +++ b/tmp/card_add_16.zsh @@ -9,8 +9,9 @@ fi echo username read id=`curl -sL "$host/users?itemsPerPage=2000"|jq ".[]|select(.username == \"$1\")"|jq -r .id` -card=2 -cp=$(($RANDOM % 500 + 300)) -s=3d -skill=3d +card=7 +cp=$(($RANDOM % 1000 + 400)) +s=yui +skill=model +st=$s curl -X POST -H "Content-Type: application/json" -d "{\"owner\":$id,\"card\":$card,\"status\":\"$s\",\"cp\":$cp,\"password\":\"$pass\",\"skill\":\"$skill\"}" -sL $host/cards diff --git a/tmp/card_limit_all.zsh b/tmp/card_limit_all.zsh index 586c91c..11be2f7 100755 --- a/tmp/card_limit_all.zsh +++ b/tmp/card_limit_all.zsh @@ -20,7 +20,7 @@ n=$((n - 1)) if [ -n "$1" ];then id=`curl -sL "$host/users?itemsPerPage=2000"|jq ".[]|select(.username == \"$1\")"|jq -r .id` if [ "ai" = "$1" ] || [ "yui" = "$1" ];then - curl -X PATCH -H "Content-Type: application/json" -d "{\"next\":\"$nd\",\"ten_at\":\"$updated_at_n\", \"updated_at\":\"$updated_at_n\", \"raid_at\":\"$raid_at_n\", \"token\":\"$token\", \"luck_at\": \"$now_at\", \"ten_kai\":0,\"ten\": false}" -s $host/users/$id + curl -X PATCH -H "Content-Type: application/json" -d "{\"token\":\"$token\", \"ten_su\": 0}" -s $host/users/$id else curl -X PATCH -H "Content-Type: application/json" -d "{\"ten_at\":\"$updated_at_n\", \"token\": \"$token\", \"raid_at\":\"$raid_at_n\"}" -s $host/users/$id #curl -X PATCH -H "Content-Type: application/json" -d "{\"updated_at\":\"$updated_at_n\", \"raid_at\":\"$raid_at_n\", \"luck_at\": \"$updated_at_n\",\"egg_at\": \"$updated_at_n\", \"token\": \"$token\"}" -s $host/users/$id @@ -33,6 +33,10 @@ for ((i=0;i<=$n;i++)) do name=`echo $data|jq ".[$i]"|jq -r .username` id=`echo $data|jq ".[$i]"|jq -r .id` + echo "{\"username\":\"$name\",\"id\":\"$id\"}" + if [ $n -ne $i ];then + echo "," + fi echo "{\"updated_at\":\"$updated_at_n\"} -s $host/users/$id" if [ "ai" = "$1" ];then curl -X PATCH -H "Content-Type: application/json" -d "{\"next\":\"$nd\", \"updated_at\":\"$updated_at_n\", \"raid_at\":\"$raid_at_n\", \"token\":\"$token\", \"luck_at\": \"$now_at\", \"luck\": 7}" -s $host/users/$id diff --git a/tmp/game_account.zsh b/tmp/game_account.zsh new file mode 100755 index 0000000..76d3d10 --- /dev/null +++ b/tmp/game_account.zsh @@ -0,0 +1,13 @@ +#!/bin/zsh +host=https://api.syui.ai +token=`cat ~/.config/atr/api_card.json|jq -r .token` + +username=ai +id=`curl -sL "$host/users?itemsPerPage=2000"|jq ".[]|select(.username == \"$username\")"|jq -r .id` + +curl -sL $host/users/$id +read +echo $id +o=false +echo $o +curl -X PATCH -H "Content-Type: application/json" -d "{\"game\":true, \"game_test\":$o, \"game_end\":$o, \"token\":\"$token\"}" -s $host/users/$id diff --git a/tmp/model_account.zsh b/tmp/model_account.zsh new file mode 100755 index 0000000..ecb006e --- /dev/null +++ b/tmp/model_account.zsh @@ -0,0 +1,14 @@ +#!/bin/zsh +host=https://api.syui.ai +token=`cat ~/.config/atr/api_card.json|jq -r .token` +if [ -z "$1" ];then + exit +fi +echo username +read +id=`curl -sL "$host/users?itemsPerPage=2000"|jq ".[]|select(.username == \"$1\")"|jq -r .id` + +echo $id +read + +curl -X PATCH -H "Content-Type: application/json" -d "{\"model_mode\":1, \"model_skill\":1,\"model_attack\":1,\"model_limit\":1,\"model_critical\":1,\"model_critical_d\":10, \"model\":true,\"token\":\"$token\"}" -s $host/users/$id diff --git a/tmp/model_account_all.zsh b/tmp/model_account_all.zsh new file mode 100755 index 0000000..c65ed45 --- /dev/null +++ b/tmp/model_account_all.zsh @@ -0,0 +1,33 @@ +#!/bin/zsh + +case $OSTYPE in + darwin*) + alias date="/opt/homebrew/bin/gdate" + ;; +esac +host=https://api.syui.ai +token=`cat ~/.config/atr/api_card.json|jq -r .token` +host_users="$host/users?itemsPerPage=2550" +updated_at_n=`date --iso-8601=seconds -d '1 days ago'` +now_at=`date --iso-8601=seconds` +raid_at_n=`date --iso-8601=seconds -d '1 days ago'` +data=`curl -sL "$host_users"|jq .` +nd=`date +"%Y%m%d"` + +n=`echo $data|jq length` +n=$((n - 1)) + +for ((i=0;i<=$n;i++)) +do + name=`echo $data|jq ".[$i]"|jq -r .username` + id=`echo $data|jq ".[$i]"|jq -r .id` + model=`echo $data|jq ".[$i]"|jq -r .model` + #echo $model + if [ "$model" = false ];then + card=`curl -sL "$host/users/$id/card?itemsPerPage=2550"|jq -r ".[]|select(.skill == \"model\")"` + if [ -n "$card" ];then + echo "\n[${id}] $name" + curl -X PATCH -H "Content-Type: application/json" -d "{\"model\":true,\"model_limit\": 1,\"token\":\"$token\"}" -s $host/users/$id + fi + fi +done diff --git a/tmp/ogent/oas_response_encoders_gen.go b/tmp/ogent/oas_response_encoders_gen.go index 09de6c3..8d7c163 100644 --- a/tmp/ogent/oas_response_encoders_gen.go +++ b/tmp/ogent/oas_response_encoders_gen.go @@ -915,7 +915,7 @@ func encodeReadGroupResponse(response ReadGroupRes, w http.ResponseWriter, span } func encodeReadUserResponse(response ReadUserRes, w http.ResponseWriter, span trace.Span) error { - w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai") + w.Header().Set("Access-Control-Allow-Origin", "*") switch response := response.(type) { case *UserRead: w.Header().Set("Content-Type", "application/json") diff --git a/tmp/ogent/ogent.go b/tmp/ogent/ogent.go index 9d568ca..3dfede2 100644 --- a/tmp/ogent/ogent.go +++ b/tmp/ogent/ogent.go @@ -603,6 +603,46 @@ func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (Crea if v, ok := req.Next.Get(); ok { b.SetNext(v) } + if v, ok := req.Model.Get(); ok { + b.SetModel(v) + } + if v, ok := req.ModelAt.Get(); ok { + b.SetModelAt(v) + } + if v, ok := req.ModelAttack.Get(); ok { + b.SetModelAttack(v) + } + if v, ok := req.ModelCriticalD.Get(); ok { + b.SetModelCriticalD(v) + } + if v, ok := req.ModelCritical.Get(); ok { + b.SetModelCritical(v) + } + if v, ok := req.ModelLimit.Get(); ok { + b.SetModelLimit(v) + } + if v, ok := req.ModelSkill.Get(); ok { + b.SetModelSkill(v) + } + if v, ok := req.ModelMode.Get(); ok { + b.SetModelMode(v) + } + if v, ok := req.Game.Get(); ok { + b.SetGame(v) + } + if v, ok := req.GameTest.Get(); ok { + b.SetGameTest(v) + } + if v, ok := req.GameEnd.Get(); ok { + b.SetGameEnd(v) + } + if v, ok := req.GameAccount.Get(); ok { + b.SetGameAccount(v) + } + if v, ok := req.GameLv.Get(); ok { + b.SetGameLv(v) + } + // Add all edges. b.AddCardIDs(req.Card...) // Persist to storage. @@ -760,6 +800,45 @@ func (h *OgentHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, param if v, ok := req.Next.Get(); ok { b.SetNext(v) } + if v, ok := req.Model.Get(); ok { + b.SetModel(v) + } + if v, ok := req.ModelAt.Get(); ok { + b.SetModelAt(v) + } + if v, ok := req.ModelAttack.Get(); ok { + b.SetModelAttack(v) + } + if v, ok := req.ModelCriticalD.Get(); ok { + b.SetModelCriticalD(v) + } + if v, ok := req.ModelCritical.Get(); ok { + b.SetModelCritical(v) + } + if v, ok := req.ModelLimit.Get(); ok { + b.SetModelLimit(v) + } + if v, ok := req.ModelSkill.Get(); ok { + b.SetModelSkill(v) + } + if v, ok := req.ModelMode.Get(); ok { + b.SetModelMode(v) + } + if v, ok := req.Game.Get(); ok { + b.SetGame(v) + } + if v, ok := req.GameTest.Get(); ok { + b.SetGameTest(v) + } + if v, ok := req.GameEnd.Get(); ok { + b.SetGameEnd(v) + } + if v, ok := req.GameAccount.Get(); ok { + b.SetGameAccount(v) + } + if v, ok := req.GameLv.Get(); ok { + b.SetGameLv(v) + } // Add all edges. if req.Card != nil { b.ClearCard().AddCardIDs(req.Card...) diff --git a/tmp/user_json.zsh b/tmp/user_json.zsh new file mode 100755 index 0000000..670705f --- /dev/null +++ b/tmp/user_json.zsh @@ -0,0 +1,35 @@ +#!/bin/zsh + +case $OSTYPE in + darwin*) + alias date="/opt/homebrew/bin/gdate" + ;; +esac +host=https://api.syui.ai +token=`cat ~/.config/atr/api_card.json|jq -r .token` +host_users="$host/users?itemsPerPage=2550" +data=`curl -sL "$host_users"|jq .` +n=`echo $data|jq length` +n=$((n - 1)) + +f=/Volumes/ssd/project/yui/Content/user.json +if [ -f $f ];then + rm $f +fi + +echo "{" >! $f + +for ((i=0;i<=$n;i++)) +do + name=`echo $data|jq ".[$i]"|jq -r .username` + id=`echo $data|jq ".[$i]"|jq -r .id` + j="\"$name\":$id" + j="\"$name\":\"$id\"" + if [ $n -ne $i ];then + j="${j}," + fi + echo $j + echo $j >> $f +done + + echo "}" >> $f