diff --git a/ent/migrate/schema.go b/ent/migrate/schema.go index 4c2d3bf..835f760 100644 --- a/ent/migrate/schema.go +++ b/ent/migrate/schema.go @@ -63,7 +63,22 @@ var ( {Name: "password", Type: field.TypeString}, {Name: "created_at", Type: field.TypeTime, Nullable: true}, {Name: "updated_at", Type: field.TypeTime, Nullable: true}, - {Name: "next", Type: field.TypeString, Nullable: true, Default: "20230521"}, + {Name: "raid_at", Type: field.TypeTime, Nullable: true}, + {Name: "luck", Type: field.TypeInt, Nullable: true}, + {Name: "luck_at", Type: field.TypeTime, Nullable: true}, + {Name: "like", Type: field.TypeInt, Nullable: true}, + {Name: "like_rank", Type: field.TypeInt, Nullable: true}, + {Name: "like_at", Type: field.TypeTime, Nullable: true}, + {Name: "ten", Type: field.TypeBool, Nullable: true}, + {Name: "ten_su", Type: field.TypeInt, Nullable: true}, + {Name: "ten_kai", Type: field.TypeInt, Nullable: true}, + {Name: "aiten", Type: field.TypeInt, Nullable: true}, + {Name: "ten_card", Type: field.TypeString, Nullable: true}, + {Name: "ten_delete", Type: field.TypeString, Nullable: true}, + {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: "20230613"}, {Name: "group_users", Type: field.TypeInt, Nullable: true}, } // UsersTable holds the schema information for the "users" table. @@ -74,7 +89,7 @@ var ( ForeignKeys: []*schema.ForeignKey{ { Symbol: "users_groups_users", - Columns: []*schema.Column{UsersColumns[9]}, + Columns: []*schema.Column{UsersColumns[24]}, RefColumns: []*schema.Column{GroupsColumns[0]}, OnDelete: schema.SetNull, }, diff --git a/ent/mutation.go b/ent/mutation.go index 41ba772..a6028d6 100644 --- a/ent/mutation.go +++ b/ent/mutation.go @@ -1422,6 +1422,27 @@ type UserMutation struct { password *string created_at *time.Time updated_at *time.Time + raid_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 + 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 clearedFields map[string]struct{} card map[int]struct{} @@ -1847,6 +1868,867 @@ func (m *UserMutation) ResetUpdatedAt() { delete(m.clearedFields, user.FieldUpdatedAt) } +// SetRaidAt sets the "raid_at" field. +func (m *UserMutation) SetRaidAt(t time.Time) { + m.raid_at = &t +} + +// RaidAt returns the value of the "raid_at" field in the mutation. +func (m *UserMutation) RaidAt() (r time.Time, exists bool) { + v := m.raid_at + if v == nil { + return + } + return *v, true +} + +// OldRaidAt returns the old "raid_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) OldRaidAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldRaidAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldRaidAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldRaidAt: %w", err) + } + return oldValue.RaidAt, nil +} + +// ClearRaidAt clears the value of the "raid_at" field. +func (m *UserMutation) ClearRaidAt() { + m.raid_at = nil + m.clearedFields[user.FieldRaidAt] = struct{}{} +} + +// RaidAtCleared returns if the "raid_at" field was cleared in this mutation. +func (m *UserMutation) RaidAtCleared() bool { + _, ok := m.clearedFields[user.FieldRaidAt] + return ok +} + +// ResetRaidAt resets all changes to the "raid_at" field. +func (m *UserMutation) ResetRaidAt() { + m.raid_at = nil + delete(m.clearedFields, user.FieldRaidAt) +} + +// SetLuck sets the "luck" field. +func (m *UserMutation) SetLuck(i int) { + m.luck = &i + m.addluck = nil +} + +// Luck returns the value of the "luck" field in the mutation. +func (m *UserMutation) Luck() (r int, exists bool) { + v := m.luck + if v == nil { + return + } + return *v, true +} + +// OldLuck returns the old "luck" 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) OldLuck(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldLuck is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldLuck requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldLuck: %w", err) + } + return oldValue.Luck, nil +} + +// AddLuck adds i to the "luck" field. +func (m *UserMutation) AddLuck(i int) { + if m.addluck != nil { + *m.addluck += i + } else { + m.addluck = &i + } +} + +// AddedLuck returns the value that was added to the "luck" field in this mutation. +func (m *UserMutation) AddedLuck() (r int, exists bool) { + v := m.addluck + if v == nil { + return + } + return *v, true +} + +// ClearLuck clears the value of the "luck" field. +func (m *UserMutation) ClearLuck() { + m.luck = nil + m.addluck = nil + m.clearedFields[user.FieldLuck] = struct{}{} +} + +// LuckCleared returns if the "luck" field was cleared in this mutation. +func (m *UserMutation) LuckCleared() bool { + _, ok := m.clearedFields[user.FieldLuck] + return ok +} + +// ResetLuck resets all changes to the "luck" field. +func (m *UserMutation) ResetLuck() { + m.luck = nil + m.addluck = nil + delete(m.clearedFields, user.FieldLuck) +} + +// SetLuckAt sets the "luck_at" field. +func (m *UserMutation) SetLuckAt(t time.Time) { + m.luck_at = &t +} + +// LuckAt returns the value of the "luck_at" field in the mutation. +func (m *UserMutation) LuckAt() (r time.Time, exists bool) { + v := m.luck_at + if v == nil { + return + } + return *v, true +} + +// OldLuckAt returns the old "luck_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) OldLuckAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldLuckAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldLuckAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldLuckAt: %w", err) + } + return oldValue.LuckAt, nil +} + +// ClearLuckAt clears the value of the "luck_at" field. +func (m *UserMutation) ClearLuckAt() { + m.luck_at = nil + m.clearedFields[user.FieldLuckAt] = struct{}{} +} + +// LuckAtCleared returns if the "luck_at" field was cleared in this mutation. +func (m *UserMutation) LuckAtCleared() bool { + _, ok := m.clearedFields[user.FieldLuckAt] + return ok +} + +// ResetLuckAt resets all changes to the "luck_at" field. +func (m *UserMutation) ResetLuckAt() { + m.luck_at = nil + delete(m.clearedFields, user.FieldLuckAt) +} + +// SetLike sets the "like" field. +func (m *UserMutation) SetLike(i int) { + m.like = &i + m.addlike = nil +} + +// Like returns the value of the "like" field in the mutation. +func (m *UserMutation) Like() (r int, exists bool) { + v := m.like + if v == nil { + return + } + return *v, true +} + +// OldLike returns the old "like" 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) OldLike(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldLike is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldLike requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldLike: %w", err) + } + return oldValue.Like, nil +} + +// AddLike adds i to the "like" field. +func (m *UserMutation) AddLike(i int) { + if m.addlike != nil { + *m.addlike += i + } else { + m.addlike = &i + } +} + +// AddedLike returns the value that was added to the "like" field in this mutation. +func (m *UserMutation) AddedLike() (r int, exists bool) { + v := m.addlike + if v == nil { + return + } + return *v, true +} + +// ClearLike clears the value of the "like" field. +func (m *UserMutation) ClearLike() { + m.like = nil + m.addlike = nil + m.clearedFields[user.FieldLike] = struct{}{} +} + +// LikeCleared returns if the "like" field was cleared in this mutation. +func (m *UserMutation) LikeCleared() bool { + _, ok := m.clearedFields[user.FieldLike] + return ok +} + +// ResetLike resets all changes to the "like" field. +func (m *UserMutation) ResetLike() { + m.like = nil + m.addlike = nil + delete(m.clearedFields, user.FieldLike) +} + +// SetLikeRank sets the "like_rank" field. +func (m *UserMutation) SetLikeRank(i int) { + m.like_rank = &i + m.addlike_rank = nil +} + +// LikeRank returns the value of the "like_rank" field in the mutation. +func (m *UserMutation) LikeRank() (r int, exists bool) { + v := m.like_rank + if v == nil { + return + } + return *v, true +} + +// OldLikeRank returns the old "like_rank" 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) OldLikeRank(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldLikeRank is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldLikeRank requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldLikeRank: %w", err) + } + return oldValue.LikeRank, nil +} + +// AddLikeRank adds i to the "like_rank" field. +func (m *UserMutation) AddLikeRank(i int) { + if m.addlike_rank != nil { + *m.addlike_rank += i + } else { + m.addlike_rank = &i + } +} + +// AddedLikeRank returns the value that was added to the "like_rank" field in this mutation. +func (m *UserMutation) AddedLikeRank() (r int, exists bool) { + v := m.addlike_rank + if v == nil { + return + } + return *v, true +} + +// ClearLikeRank clears the value of the "like_rank" field. +func (m *UserMutation) ClearLikeRank() { + m.like_rank = nil + m.addlike_rank = nil + m.clearedFields[user.FieldLikeRank] = struct{}{} +} + +// LikeRankCleared returns if the "like_rank" field was cleared in this mutation. +func (m *UserMutation) LikeRankCleared() bool { + _, ok := m.clearedFields[user.FieldLikeRank] + return ok +} + +// ResetLikeRank resets all changes to the "like_rank" field. +func (m *UserMutation) ResetLikeRank() { + m.like_rank = nil + m.addlike_rank = nil + delete(m.clearedFields, user.FieldLikeRank) +} + +// SetLikeAt sets the "like_at" field. +func (m *UserMutation) SetLikeAt(t time.Time) { + m.like_at = &t +} + +// LikeAt returns the value of the "like_at" field in the mutation. +func (m *UserMutation) LikeAt() (r time.Time, exists bool) { + v := m.like_at + if v == nil { + return + } + return *v, true +} + +// OldLikeAt returns the old "like_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) OldLikeAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldLikeAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldLikeAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldLikeAt: %w", err) + } + return oldValue.LikeAt, nil +} + +// ClearLikeAt clears the value of the "like_at" field. +func (m *UserMutation) ClearLikeAt() { + m.like_at = nil + m.clearedFields[user.FieldLikeAt] = struct{}{} +} + +// LikeAtCleared returns if the "like_at" field was cleared in this mutation. +func (m *UserMutation) LikeAtCleared() bool { + _, ok := m.clearedFields[user.FieldLikeAt] + return ok +} + +// ResetLikeAt resets all changes to the "like_at" field. +func (m *UserMutation) ResetLikeAt() { + m.like_at = nil + delete(m.clearedFields, user.FieldLikeAt) +} + +// SetTen sets the "ten" field. +func (m *UserMutation) SetTen(b bool) { + m.ten = &b +} + +// Ten returns the value of the "ten" field in the mutation. +func (m *UserMutation) Ten() (r bool, exists bool) { + v := m.ten + if v == nil { + return + } + return *v, true +} + +// OldTen returns the old "ten" 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) OldTen(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTen is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTen requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTen: %w", err) + } + return oldValue.Ten, nil +} + +// ClearTen clears the value of the "ten" field. +func (m *UserMutation) ClearTen() { + m.ten = nil + m.clearedFields[user.FieldTen] = struct{}{} +} + +// TenCleared returns if the "ten" field was cleared in this mutation. +func (m *UserMutation) TenCleared() bool { + _, ok := m.clearedFields[user.FieldTen] + return ok +} + +// ResetTen resets all changes to the "ten" field. +func (m *UserMutation) ResetTen() { + m.ten = nil + delete(m.clearedFields, user.FieldTen) +} + +// SetTenSu sets the "ten_su" field. +func (m *UserMutation) SetTenSu(i int) { + m.ten_su = &i + m.addten_su = nil +} + +// TenSu returns the value of the "ten_su" field in the mutation. +func (m *UserMutation) TenSu() (r int, exists bool) { + v := m.ten_su + if v == nil { + return + } + return *v, true +} + +// OldTenSu returns the old "ten_su" 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) OldTenSu(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTenSu is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTenSu requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTenSu: %w", err) + } + return oldValue.TenSu, nil +} + +// AddTenSu adds i to the "ten_su" field. +func (m *UserMutation) AddTenSu(i int) { + if m.addten_su != nil { + *m.addten_su += i + } else { + m.addten_su = &i + } +} + +// AddedTenSu returns the value that was added to the "ten_su" field in this mutation. +func (m *UserMutation) AddedTenSu() (r int, exists bool) { + v := m.addten_su + if v == nil { + return + } + return *v, true +} + +// ClearTenSu clears the value of the "ten_su" field. +func (m *UserMutation) ClearTenSu() { + m.ten_su = nil + m.addten_su = nil + m.clearedFields[user.FieldTenSu] = struct{}{} +} + +// TenSuCleared returns if the "ten_su" field was cleared in this mutation. +func (m *UserMutation) TenSuCleared() bool { + _, ok := m.clearedFields[user.FieldTenSu] + return ok +} + +// ResetTenSu resets all changes to the "ten_su" field. +func (m *UserMutation) ResetTenSu() { + m.ten_su = nil + m.addten_su = nil + delete(m.clearedFields, user.FieldTenSu) +} + +// SetTenKai sets the "ten_kai" field. +func (m *UserMutation) SetTenKai(i int) { + m.ten_kai = &i + m.addten_kai = nil +} + +// TenKai returns the value of the "ten_kai" field in the mutation. +func (m *UserMutation) TenKai() (r int, exists bool) { + v := m.ten_kai + if v == nil { + return + } + return *v, true +} + +// OldTenKai returns the old "ten_kai" 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) OldTenKai(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTenKai is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTenKai requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTenKai: %w", err) + } + return oldValue.TenKai, nil +} + +// AddTenKai adds i to the "ten_kai" field. +func (m *UserMutation) AddTenKai(i int) { + if m.addten_kai != nil { + *m.addten_kai += i + } else { + m.addten_kai = &i + } +} + +// AddedTenKai returns the value that was added to the "ten_kai" field in this mutation. +func (m *UserMutation) AddedTenKai() (r int, exists bool) { + v := m.addten_kai + if v == nil { + return + } + return *v, true +} + +// ClearTenKai clears the value of the "ten_kai" field. +func (m *UserMutation) ClearTenKai() { + m.ten_kai = nil + m.addten_kai = nil + m.clearedFields[user.FieldTenKai] = struct{}{} +} + +// TenKaiCleared returns if the "ten_kai" field was cleared in this mutation. +func (m *UserMutation) TenKaiCleared() bool { + _, ok := m.clearedFields[user.FieldTenKai] + return ok +} + +// ResetTenKai resets all changes to the "ten_kai" field. +func (m *UserMutation) ResetTenKai() { + m.ten_kai = nil + m.addten_kai = nil + delete(m.clearedFields, user.FieldTenKai) +} + +// SetAiten sets the "aiten" field. +func (m *UserMutation) SetAiten(i int) { + m.aiten = &i + m.addaiten = nil +} + +// Aiten returns the value of the "aiten" field in the mutation. +func (m *UserMutation) Aiten() (r int, exists bool) { + v := m.aiten + if v == nil { + return + } + return *v, true +} + +// OldAiten returns the old "aiten" 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) OldAiten(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldAiten is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldAiten requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldAiten: %w", err) + } + return oldValue.Aiten, nil +} + +// AddAiten adds i to the "aiten" field. +func (m *UserMutation) AddAiten(i int) { + if m.addaiten != nil { + *m.addaiten += i + } else { + m.addaiten = &i + } +} + +// AddedAiten returns the value that was added to the "aiten" field in this mutation. +func (m *UserMutation) AddedAiten() (r int, exists bool) { + v := m.addaiten + if v == nil { + return + } + return *v, true +} + +// ClearAiten clears the value of the "aiten" field. +func (m *UserMutation) ClearAiten() { + m.aiten = nil + m.addaiten = nil + m.clearedFields[user.FieldAiten] = struct{}{} +} + +// AitenCleared returns if the "aiten" field was cleared in this mutation. +func (m *UserMutation) AitenCleared() bool { + _, ok := m.clearedFields[user.FieldAiten] + return ok +} + +// ResetAiten resets all changes to the "aiten" field. +func (m *UserMutation) ResetAiten() { + m.aiten = nil + m.addaiten = nil + delete(m.clearedFields, user.FieldAiten) +} + +// SetTenCard sets the "ten_card" field. +func (m *UserMutation) SetTenCard(s string) { + m.ten_card = &s +} + +// TenCard returns the value of the "ten_card" field in the mutation. +func (m *UserMutation) TenCard() (r string, exists bool) { + v := m.ten_card + if v == nil { + return + } + return *v, true +} + +// OldTenCard returns the old "ten_card" 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) OldTenCard(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTenCard is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTenCard requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTenCard: %w", err) + } + return oldValue.TenCard, nil +} + +// ClearTenCard clears the value of the "ten_card" field. +func (m *UserMutation) ClearTenCard() { + m.ten_card = nil + m.clearedFields[user.FieldTenCard] = struct{}{} +} + +// TenCardCleared returns if the "ten_card" field was cleared in this mutation. +func (m *UserMutation) TenCardCleared() bool { + _, ok := m.clearedFields[user.FieldTenCard] + return ok +} + +// ResetTenCard resets all changes to the "ten_card" field. +func (m *UserMutation) ResetTenCard() { + m.ten_card = nil + delete(m.clearedFields, user.FieldTenCard) +} + +// SetTenDelete sets the "ten_delete" field. +func (m *UserMutation) SetTenDelete(s string) { + m.ten_delete = &s +} + +// TenDelete returns the value of the "ten_delete" field in the mutation. +func (m *UserMutation) TenDelete() (r string, exists bool) { + v := m.ten_delete + if v == nil { + return + } + return *v, true +} + +// OldTenDelete returns the old "ten_delete" 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) OldTenDelete(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTenDelete is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTenDelete requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTenDelete: %w", err) + } + return oldValue.TenDelete, nil +} + +// ClearTenDelete clears the value of the "ten_delete" field. +func (m *UserMutation) ClearTenDelete() { + m.ten_delete = nil + m.clearedFields[user.FieldTenDelete] = struct{}{} +} + +// TenDeleteCleared returns if the "ten_delete" field was cleared in this mutation. +func (m *UserMutation) TenDeleteCleared() bool { + _, ok := m.clearedFields[user.FieldTenDelete] + return ok +} + +// ResetTenDelete resets all changes to the "ten_delete" field. +func (m *UserMutation) ResetTenDelete() { + m.ten_delete = nil + delete(m.clearedFields, user.FieldTenDelete) +} + +// SetTenPost sets the "ten_post" field. +func (m *UserMutation) SetTenPost(s string) { + m.ten_post = &s +} + +// TenPost returns the value of the "ten_post" field in the mutation. +func (m *UserMutation) TenPost() (r string, exists bool) { + v := m.ten_post + if v == nil { + return + } + return *v, true +} + +// OldTenPost returns the old "ten_post" 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) OldTenPost(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTenPost is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTenPost requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTenPost: %w", err) + } + return oldValue.TenPost, nil +} + +// ClearTenPost clears the value of the "ten_post" field. +func (m *UserMutation) ClearTenPost() { + m.ten_post = nil + m.clearedFields[user.FieldTenPost] = struct{}{} +} + +// TenPostCleared returns if the "ten_post" field was cleared in this mutation. +func (m *UserMutation) TenPostCleared() bool { + _, ok := m.clearedFields[user.FieldTenPost] + return ok +} + +// ResetTenPost resets all changes to the "ten_post" field. +func (m *UserMutation) ResetTenPost() { + m.ten_post = nil + delete(m.clearedFields, user.FieldTenPost) +} + +// SetTenGet sets the "ten_get" field. +func (m *UserMutation) SetTenGet(s string) { + m.ten_get = &s +} + +// TenGet returns the value of the "ten_get" field in the mutation. +func (m *UserMutation) TenGet() (r string, exists bool) { + v := m.ten_get + if v == nil { + return + } + return *v, true +} + +// OldTenGet returns the old "ten_get" 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) OldTenGet(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTenGet is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTenGet requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTenGet: %w", err) + } + return oldValue.TenGet, nil +} + +// ClearTenGet clears the value of the "ten_get" field. +func (m *UserMutation) ClearTenGet() { + m.ten_get = nil + m.clearedFields[user.FieldTenGet] = struct{}{} +} + +// TenGetCleared returns if the "ten_get" field was cleared in this mutation. +func (m *UserMutation) TenGetCleared() bool { + _, ok := m.clearedFields[user.FieldTenGet] + return ok +} + +// ResetTenGet resets all changes to the "ten_get" field. +func (m *UserMutation) ResetTenGet() { + m.ten_get = nil + delete(m.clearedFields, user.FieldTenGet) +} + +// SetTenAt sets the "ten_at" field. +func (m *UserMutation) SetTenAt(t time.Time) { + m.ten_at = &t +} + +// TenAt returns the value of the "ten_at" field in the mutation. +func (m *UserMutation) TenAt() (r time.Time, exists bool) { + v := m.ten_at + if v == nil { + return + } + return *v, true +} + +// OldTenAt returns the old "ten_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) OldTenAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTenAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTenAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTenAt: %w", err) + } + return oldValue.TenAt, nil +} + +// ClearTenAt clears the value of the "ten_at" field. +func (m *UserMutation) ClearTenAt() { + m.ten_at = nil + m.clearedFields[user.FieldTenAt] = struct{}{} +} + +// TenAtCleared returns if the "ten_at" field was cleared in this mutation. +func (m *UserMutation) TenAtCleared() bool { + _, ok := m.clearedFields[user.FieldTenAt] + return ok +} + +// ResetTenAt resets all changes to the "ten_at" field. +func (m *UserMutation) ResetTenAt() { + m.ten_at = nil + delete(m.clearedFields, user.FieldTenAt) +} + // SetNext sets the "next" field. func (m *UserMutation) SetNext(s string) { m.next = &s @@ -1984,7 +2866,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, 8) + fields := make([]string, 0, 23) if m.username != nil { fields = append(fields, user.FieldUsername) } @@ -2006,6 +2888,51 @@ func (m *UserMutation) Fields() []string { if m.updated_at != nil { fields = append(fields, user.FieldUpdatedAt) } + if m.raid_at != nil { + fields = append(fields, user.FieldRaidAt) + } + if m.luck != nil { + fields = append(fields, user.FieldLuck) + } + if m.luck_at != nil { + fields = append(fields, user.FieldLuckAt) + } + if m.like != nil { + fields = append(fields, user.FieldLike) + } + if m.like_rank != nil { + fields = append(fields, user.FieldLikeRank) + } + if m.like_at != nil { + fields = append(fields, user.FieldLikeAt) + } + if m.ten != nil { + fields = append(fields, user.FieldTen) + } + if m.ten_su != nil { + fields = append(fields, user.FieldTenSu) + } + if m.ten_kai != nil { + fields = append(fields, user.FieldTenKai) + } + if m.aiten != nil { + fields = append(fields, user.FieldAiten) + } + if m.ten_card != nil { + fields = append(fields, user.FieldTenCard) + } + if m.ten_delete != nil { + fields = append(fields, user.FieldTenDelete) + } + if m.ten_post != nil { + fields = append(fields, user.FieldTenPost) + } + if m.ten_get != nil { + fields = append(fields, user.FieldTenGet) + } + if m.ten_at != nil { + fields = append(fields, user.FieldTenAt) + } if m.next != nil { fields = append(fields, user.FieldNext) } @@ -2031,6 +2958,36 @@ func (m *UserMutation) Field(name string) (ent.Value, bool) { return m.CreatedAt() case user.FieldUpdatedAt: return m.UpdatedAt() + case user.FieldRaidAt: + return m.RaidAt() + case user.FieldLuck: + return m.Luck() + case user.FieldLuckAt: + return m.LuckAt() + case user.FieldLike: + return m.Like() + case user.FieldLikeRank: + return m.LikeRank() + case user.FieldLikeAt: + return m.LikeAt() + case user.FieldTen: + return m.Ten() + case user.FieldTenSu: + return m.TenSu() + case user.FieldTenKai: + return m.TenKai() + case user.FieldAiten: + return m.Aiten() + case user.FieldTenCard: + return m.TenCard() + case user.FieldTenDelete: + return m.TenDelete() + case user.FieldTenPost: + return m.TenPost() + case user.FieldTenGet: + return m.TenGet() + case user.FieldTenAt: + return m.TenAt() case user.FieldNext: return m.Next() } @@ -2056,6 +3013,36 @@ func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, er return m.OldCreatedAt(ctx) case user.FieldUpdatedAt: return m.OldUpdatedAt(ctx) + case user.FieldRaidAt: + return m.OldRaidAt(ctx) + case user.FieldLuck: + return m.OldLuck(ctx) + case user.FieldLuckAt: + return m.OldLuckAt(ctx) + case user.FieldLike: + return m.OldLike(ctx) + case user.FieldLikeRank: + return m.OldLikeRank(ctx) + case user.FieldLikeAt: + return m.OldLikeAt(ctx) + case user.FieldTen: + return m.OldTen(ctx) + case user.FieldTenSu: + return m.OldTenSu(ctx) + case user.FieldTenKai: + return m.OldTenKai(ctx) + case user.FieldAiten: + return m.OldAiten(ctx) + case user.FieldTenCard: + return m.OldTenCard(ctx) + case user.FieldTenDelete: + return m.OldTenDelete(ctx) + case user.FieldTenPost: + return m.OldTenPost(ctx) + case user.FieldTenGet: + return m.OldTenGet(ctx) + case user.FieldTenAt: + return m.OldTenAt(ctx) case user.FieldNext: return m.OldNext(ctx) } @@ -2116,6 +3103,111 @@ func (m *UserMutation) SetField(name string, value ent.Value) error { } m.SetUpdatedAt(v) return nil + case user.FieldRaidAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetRaidAt(v) + return nil + case user.FieldLuck: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetLuck(v) + return nil + case user.FieldLuckAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetLuckAt(v) + return nil + case user.FieldLike: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetLike(v) + return nil + case user.FieldLikeRank: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetLikeRank(v) + return nil + case user.FieldLikeAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetLikeAt(v) + return nil + case user.FieldTen: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTen(v) + return nil + case user.FieldTenSu: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTenSu(v) + return nil + case user.FieldTenKai: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTenKai(v) + return nil + case user.FieldAiten: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetAiten(v) + return nil + case user.FieldTenCard: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTenCard(v) + return nil + case user.FieldTenDelete: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTenDelete(v) + return nil + case user.FieldTenPost: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTenPost(v) + return nil + case user.FieldTenGet: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTenGet(v) + return nil + case user.FieldTenAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTenAt(v) + return nil case user.FieldNext: v, ok := value.(string) if !ok { @@ -2130,13 +3222,46 @@ func (m *UserMutation) SetField(name string, value ent.Value) error { // AddedFields returns all numeric fields that were incremented/decremented during // this mutation. func (m *UserMutation) AddedFields() []string { - return nil + var fields []string + if m.addluck != nil { + fields = append(fields, user.FieldLuck) + } + if m.addlike != nil { + fields = append(fields, user.FieldLike) + } + if m.addlike_rank != nil { + fields = append(fields, user.FieldLikeRank) + } + if m.addten_su != nil { + fields = append(fields, user.FieldTenSu) + } + if m.addten_kai != nil { + fields = append(fields, user.FieldTenKai) + } + if m.addaiten != nil { + fields = append(fields, user.FieldAiten) + } + return fields } // AddedField returns the numeric value that was incremented/decremented on a field // with the given name. The second boolean return value indicates that this field // was not set, or was not defined in the schema. func (m *UserMutation) AddedField(name string) (ent.Value, bool) { + switch name { + case user.FieldLuck: + return m.AddedLuck() + case user.FieldLike: + return m.AddedLike() + case user.FieldLikeRank: + return m.AddedLikeRank() + case user.FieldTenSu: + return m.AddedTenSu() + case user.FieldTenKai: + return m.AddedTenKai() + case user.FieldAiten: + return m.AddedAiten() + } return nil, false } @@ -2145,6 +3270,48 @@ func (m *UserMutation) AddedField(name string) (ent.Value, bool) { // type. func (m *UserMutation) AddField(name string, value ent.Value) error { switch name { + case user.FieldLuck: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddLuck(v) + return nil + case user.FieldLike: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddLike(v) + return nil + case user.FieldLikeRank: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddLikeRank(v) + return nil + case user.FieldTenSu: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddTenSu(v) + return nil + case user.FieldTenKai: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddTenKai(v) + return nil + case user.FieldAiten: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddAiten(v) + return nil } return fmt.Errorf("unknown User numeric field %s", name) } @@ -2168,6 +3335,51 @@ func (m *UserMutation) ClearedFields() []string { if m.FieldCleared(user.FieldUpdatedAt) { fields = append(fields, user.FieldUpdatedAt) } + if m.FieldCleared(user.FieldRaidAt) { + fields = append(fields, user.FieldRaidAt) + } + if m.FieldCleared(user.FieldLuck) { + fields = append(fields, user.FieldLuck) + } + if m.FieldCleared(user.FieldLuckAt) { + fields = append(fields, user.FieldLuckAt) + } + if m.FieldCleared(user.FieldLike) { + fields = append(fields, user.FieldLike) + } + if m.FieldCleared(user.FieldLikeRank) { + fields = append(fields, user.FieldLikeRank) + } + if m.FieldCleared(user.FieldLikeAt) { + fields = append(fields, user.FieldLikeAt) + } + if m.FieldCleared(user.FieldTen) { + fields = append(fields, user.FieldTen) + } + if m.FieldCleared(user.FieldTenSu) { + fields = append(fields, user.FieldTenSu) + } + if m.FieldCleared(user.FieldTenKai) { + fields = append(fields, user.FieldTenKai) + } + if m.FieldCleared(user.FieldAiten) { + fields = append(fields, user.FieldAiten) + } + if m.FieldCleared(user.FieldTenCard) { + fields = append(fields, user.FieldTenCard) + } + if m.FieldCleared(user.FieldTenDelete) { + fields = append(fields, user.FieldTenDelete) + } + if m.FieldCleared(user.FieldTenPost) { + fields = append(fields, user.FieldTenPost) + } + if m.FieldCleared(user.FieldTenGet) { + fields = append(fields, user.FieldTenGet) + } + if m.FieldCleared(user.FieldTenAt) { + fields = append(fields, user.FieldTenAt) + } if m.FieldCleared(user.FieldNext) { fields = append(fields, user.FieldNext) } @@ -2200,6 +3412,51 @@ func (m *UserMutation) ClearField(name string) error { case user.FieldUpdatedAt: m.ClearUpdatedAt() return nil + case user.FieldRaidAt: + m.ClearRaidAt() + return nil + case user.FieldLuck: + m.ClearLuck() + return nil + case user.FieldLuckAt: + m.ClearLuckAt() + return nil + case user.FieldLike: + m.ClearLike() + return nil + case user.FieldLikeRank: + m.ClearLikeRank() + return nil + case user.FieldLikeAt: + m.ClearLikeAt() + return nil + case user.FieldTen: + m.ClearTen() + return nil + case user.FieldTenSu: + m.ClearTenSu() + return nil + case user.FieldTenKai: + m.ClearTenKai() + return nil + case user.FieldAiten: + m.ClearAiten() + return nil + case user.FieldTenCard: + m.ClearTenCard() + return nil + case user.FieldTenDelete: + m.ClearTenDelete() + return nil + case user.FieldTenPost: + m.ClearTenPost() + return nil + case user.FieldTenGet: + m.ClearTenGet() + return nil + case user.FieldTenAt: + m.ClearTenAt() + return nil case user.FieldNext: m.ClearNext() return nil @@ -2232,6 +3489,51 @@ func (m *UserMutation) ResetField(name string) error { case user.FieldUpdatedAt: m.ResetUpdatedAt() return nil + case user.FieldRaidAt: + m.ResetRaidAt() + return nil + case user.FieldLuck: + m.ResetLuck() + return nil + case user.FieldLuckAt: + m.ResetLuckAt() + return nil + case user.FieldLike: + m.ResetLike() + return nil + case user.FieldLikeRank: + m.ResetLikeRank() + return nil + case user.FieldLikeAt: + m.ResetLikeAt() + return nil + case user.FieldTen: + m.ResetTen() + return nil + case user.FieldTenSu: + m.ResetTenSu() + return nil + case user.FieldTenKai: + m.ResetTenKai() + return nil + case user.FieldAiten: + m.ResetAiten() + return nil + case user.FieldTenCard: + m.ResetTenCard() + return nil + case user.FieldTenDelete: + m.ResetTenDelete() + return nil + case user.FieldTenPost: + m.ResetTenPost() + return nil + case user.FieldTenGet: + m.ResetTenGet() + return nil + case user.FieldTenAt: + m.ResetTenAt() + return nil case user.FieldNext: m.ResetNext() return nil diff --git a/ent/ogent/oas_json_gen.go b/ent/ogent/oas_json_gen.go index bc7023c..1da676f 100644 --- a/ent/ogent/oas_json_gen.go +++ b/ent/ogent/oas_json_gen.go @@ -455,6 +455,96 @@ func (s *CardOwnerRead) encodeFields(e *jx.Encoder) { s.UpdatedAt.Encode(e, json.EncodeDateTime) } } + { + if s.RaidAt.Set { + e.FieldStart("raid_at") + s.RaidAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Luck.Set { + e.FieldStart("luck") + s.Luck.Encode(e) + } + } + { + if s.LuckAt.Set { + e.FieldStart("luck_at") + s.LuckAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Like.Set { + e.FieldStart("like") + s.Like.Encode(e) + } + } + { + if s.LikeRank.Set { + e.FieldStart("like_rank") + s.LikeRank.Encode(e) + } + } + { + if s.LikeAt.Set { + e.FieldStart("like_at") + s.LikeAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Ten.Set { + e.FieldStart("ten") + s.Ten.Encode(e) + } + } + { + if s.TenSu.Set { + e.FieldStart("ten_su") + s.TenSu.Encode(e) + } + } + { + if s.TenKai.Set { + e.FieldStart("ten_kai") + s.TenKai.Encode(e) + } + } + { + if s.Aiten.Set { + e.FieldStart("aiten") + s.Aiten.Encode(e) + } + } + { + if s.TenCard.Set { + e.FieldStart("ten_card") + s.TenCard.Encode(e) + } + } + { + if s.TenDelete.Set { + e.FieldStart("ten_delete") + s.TenDelete.Encode(e) + } + } + { + if s.TenPost.Set { + e.FieldStart("ten_post") + s.TenPost.Encode(e) + } + } + { + if s.TenGet.Set { + e.FieldStart("ten_get") + s.TenGet.Encode(e) + } + } + { + if s.TenAt.Set { + e.FieldStart("ten_at") + s.TenAt.Encode(e, json.EncodeDateTime) + } + } { if s.Next.Set { e.FieldStart("next") @@ -463,14 +553,29 @@ func (s *CardOwnerRead) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfCardOwnerRead = [7]string{ - 0: "id", - 1: "username", - 2: "did", - 3: "delete", - 4: "created_at", - 5: "updated_at", - 6: "next", +var jsonFieldsNameOfCardOwnerRead = [22]string{ + 0: "id", + 1: "username", + 2: "did", + 3: "delete", + 4: "created_at", + 5: "updated_at", + 6: "raid_at", + 7: "luck", + 8: "luck_at", + 9: "like", + 10: "like_rank", + 11: "like_at", + 12: "ten", + 13: "ten_su", + 14: "ten_kai", + 15: "aiten", + 16: "ten_card", + 17: "ten_delete", + 18: "ten_post", + 19: "ten_get", + 20: "ten_at", + 21: "next", } // Decode decodes CardOwnerRead from json. @@ -478,7 +583,7 @@ func (s *CardOwnerRead) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode CardOwnerRead to nil") } - var requiredBitSet [1]uint8 + var requiredBitSet [3]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -546,6 +651,156 @@ func (s *CardOwnerRead) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } + case "raid_at": + if err := func() error { + s.RaidAt.Reset() + if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raid_at\"") + } + case "luck": + if err := func() error { + s.Luck.Reset() + if err := s.Luck.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck\"") + } + case "luck_at": + if err := func() error { + s.LuckAt.Reset() + if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck_at\"") + } + case "like": + if err := func() error { + s.Like.Reset() + if err := s.Like.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like\"") + } + case "like_rank": + if err := func() error { + s.LikeRank.Reset() + if err := s.LikeRank.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_rank\"") + } + case "like_at": + if err := func() error { + s.LikeAt.Reset() + if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_at\"") + } + case "ten": + if err := func() error { + s.Ten.Reset() + if err := s.Ten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten\"") + } + case "ten_su": + if err := func() error { + s.TenSu.Reset() + if err := s.TenSu.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_su\"") + } + case "ten_kai": + if err := func() error { + s.TenKai.Reset() + if err := s.TenKai.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_kai\"") + } + case "aiten": + if err := func() error { + s.Aiten.Reset() + if err := s.Aiten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"aiten\"") + } + case "ten_card": + if err := func() error { + s.TenCard.Reset() + if err := s.TenCard.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_card\"") + } + case "ten_delete": + if err := func() error { + s.TenDelete.Reset() + if err := s.TenDelete.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_delete\"") + } + case "ten_post": + if err := func() error { + s.TenPost.Reset() + if err := s.TenPost.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_post\"") + } + case "ten_get": + if err := func() error { + s.TenGet.Reset() + if err := s.TenGet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_get\"") + } + case "ten_at": + if err := func() error { + s.TenAt.Reset() + if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_at\"") + } case "next": if err := func() error { s.Next.Reset() @@ -565,8 +820,10 @@ func (s *CardOwnerRead) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ + for i, mask := range [3]uint8{ 0b00000011, + 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -1421,6 +1678,96 @@ func (s *CreateUserReq) encodeFields(e *jx.Encoder) { s.UpdatedAt.Encode(e, json.EncodeDateTime) } } + { + if s.RaidAt.Set { + e.FieldStart("raid_at") + s.RaidAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Luck.Set { + e.FieldStart("luck") + s.Luck.Encode(e) + } + } + { + if s.LuckAt.Set { + e.FieldStart("luck_at") + s.LuckAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Like.Set { + e.FieldStart("like") + s.Like.Encode(e) + } + } + { + if s.LikeRank.Set { + e.FieldStart("like_rank") + s.LikeRank.Encode(e) + } + } + { + if s.LikeAt.Set { + e.FieldStart("like_at") + s.LikeAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Ten.Set { + e.FieldStart("ten") + s.Ten.Encode(e) + } + } + { + if s.TenSu.Set { + e.FieldStart("ten_su") + s.TenSu.Encode(e) + } + } + { + if s.TenKai.Set { + e.FieldStart("ten_kai") + s.TenKai.Encode(e) + } + } + { + if s.Aiten.Set { + e.FieldStart("aiten") + s.Aiten.Encode(e) + } + } + { + if s.TenCard.Set { + e.FieldStart("ten_card") + s.TenCard.Encode(e) + } + } + { + if s.TenDelete.Set { + e.FieldStart("ten_delete") + s.TenDelete.Encode(e) + } + } + { + if s.TenPost.Set { + e.FieldStart("ten_post") + s.TenPost.Encode(e) + } + } + { + if s.TenGet.Set { + e.FieldStart("ten_get") + s.TenGet.Encode(e) + } + } + { + if s.TenAt.Set { + e.FieldStart("ten_at") + s.TenAt.Encode(e, json.EncodeDateTime) + } + } { if s.Next.Set { e.FieldStart("next") @@ -1439,16 +1786,31 @@ func (s *CreateUserReq) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfCreateUserReq = [9]string{ - 0: "username", - 1: "did", - 2: "delete", - 3: "token", - 4: "password", - 5: "created_at", - 6: "updated_at", - 7: "next", - 8: "card", +var jsonFieldsNameOfCreateUserReq = [24]string{ + 0: "username", + 1: "did", + 2: "delete", + 3: "token", + 4: "password", + 5: "created_at", + 6: "updated_at", + 7: "raid_at", + 8: "luck", + 9: "luck_at", + 10: "like", + 11: "like_rank", + 12: "like_at", + 13: "ten", + 14: "ten_su", + 15: "ten_kai", + 16: "aiten", + 17: "ten_card", + 18: "ten_delete", + 19: "ten_post", + 20: "ten_get", + 21: "ten_at", + 22: "next", + 23: "card", } // Decode decodes CreateUserReq from json. @@ -1456,7 +1818,7 @@ func (s *CreateUserReq) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode CreateUserReq to nil") } - var requiredBitSet [2]uint8 + var requiredBitSet [3]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -1534,6 +1896,156 @@ func (s *CreateUserReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } + case "raid_at": + if err := func() error { + s.RaidAt.Reset() + if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raid_at\"") + } + case "luck": + if err := func() error { + s.Luck.Reset() + if err := s.Luck.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck\"") + } + case "luck_at": + if err := func() error { + s.LuckAt.Reset() + if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck_at\"") + } + case "like": + if err := func() error { + s.Like.Reset() + if err := s.Like.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like\"") + } + case "like_rank": + if err := func() error { + s.LikeRank.Reset() + if err := s.LikeRank.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_rank\"") + } + case "like_at": + if err := func() error { + s.LikeAt.Reset() + if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_at\"") + } + case "ten": + if err := func() error { + s.Ten.Reset() + if err := s.Ten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten\"") + } + case "ten_su": + if err := func() error { + s.TenSu.Reset() + if err := s.TenSu.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_su\"") + } + case "ten_kai": + if err := func() error { + s.TenKai.Reset() + if err := s.TenKai.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_kai\"") + } + case "aiten": + if err := func() error { + s.Aiten.Reset() + if err := s.Aiten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"aiten\"") + } + case "ten_card": + if err := func() error { + s.TenCard.Reset() + if err := s.TenCard.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_card\"") + } + case "ten_delete": + if err := func() error { + s.TenDelete.Reset() + if err := s.TenDelete.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_delete\"") + } + case "ten_post": + if err := func() error { + s.TenPost.Reset() + if err := s.TenPost.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_post\"") + } + case "ten_get": + if err := func() error { + s.TenGet.Reset() + if err := s.TenGet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_get\"") + } + case "ten_at": + if err := func() error { + s.TenAt.Reset() + if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_at\"") + } case "next": if err := func() error { s.Next.Reset() @@ -1572,9 +2084,10 @@ func (s *CreateUserReq) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ + for i, mask := range [3]uint8{ 0b00010001, 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -2123,6 +2636,96 @@ func (s *GroupUsersList) encodeFields(e *jx.Encoder) { s.UpdatedAt.Encode(e, json.EncodeDateTime) } } + { + if s.RaidAt.Set { + e.FieldStart("raid_at") + s.RaidAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Luck.Set { + e.FieldStart("luck") + s.Luck.Encode(e) + } + } + { + if s.LuckAt.Set { + e.FieldStart("luck_at") + s.LuckAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Like.Set { + e.FieldStart("like") + s.Like.Encode(e) + } + } + { + if s.LikeRank.Set { + e.FieldStart("like_rank") + s.LikeRank.Encode(e) + } + } + { + if s.LikeAt.Set { + e.FieldStart("like_at") + s.LikeAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Ten.Set { + e.FieldStart("ten") + s.Ten.Encode(e) + } + } + { + if s.TenSu.Set { + e.FieldStart("ten_su") + s.TenSu.Encode(e) + } + } + { + if s.TenKai.Set { + e.FieldStart("ten_kai") + s.TenKai.Encode(e) + } + } + { + if s.Aiten.Set { + e.FieldStart("aiten") + s.Aiten.Encode(e) + } + } + { + if s.TenCard.Set { + e.FieldStart("ten_card") + s.TenCard.Encode(e) + } + } + { + if s.TenDelete.Set { + e.FieldStart("ten_delete") + s.TenDelete.Encode(e) + } + } + { + if s.TenPost.Set { + e.FieldStart("ten_post") + s.TenPost.Encode(e) + } + } + { + if s.TenGet.Set { + e.FieldStart("ten_get") + s.TenGet.Encode(e) + } + } + { + if s.TenAt.Set { + e.FieldStart("ten_at") + s.TenAt.Encode(e, json.EncodeDateTime) + } + } { if s.Next.Set { e.FieldStart("next") @@ -2131,14 +2734,29 @@ func (s *GroupUsersList) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfGroupUsersList = [7]string{ - 0: "id", - 1: "username", - 2: "did", - 3: "delete", - 4: "created_at", - 5: "updated_at", - 6: "next", +var jsonFieldsNameOfGroupUsersList = [22]string{ + 0: "id", + 1: "username", + 2: "did", + 3: "delete", + 4: "created_at", + 5: "updated_at", + 6: "raid_at", + 7: "luck", + 8: "luck_at", + 9: "like", + 10: "like_rank", + 11: "like_at", + 12: "ten", + 13: "ten_su", + 14: "ten_kai", + 15: "aiten", + 16: "ten_card", + 17: "ten_delete", + 18: "ten_post", + 19: "ten_get", + 20: "ten_at", + 21: "next", } // Decode decodes GroupUsersList from json. @@ -2146,7 +2764,7 @@ func (s *GroupUsersList) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode GroupUsersList to nil") } - var requiredBitSet [1]uint8 + var requiredBitSet [3]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -2214,6 +2832,156 @@ func (s *GroupUsersList) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } + case "raid_at": + if err := func() error { + s.RaidAt.Reset() + if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raid_at\"") + } + case "luck": + if err := func() error { + s.Luck.Reset() + if err := s.Luck.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck\"") + } + case "luck_at": + if err := func() error { + s.LuckAt.Reset() + if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck_at\"") + } + case "like": + if err := func() error { + s.Like.Reset() + if err := s.Like.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like\"") + } + case "like_rank": + if err := func() error { + s.LikeRank.Reset() + if err := s.LikeRank.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_rank\"") + } + case "like_at": + if err := func() error { + s.LikeAt.Reset() + if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_at\"") + } + case "ten": + if err := func() error { + s.Ten.Reset() + if err := s.Ten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten\"") + } + case "ten_su": + if err := func() error { + s.TenSu.Reset() + if err := s.TenSu.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_su\"") + } + case "ten_kai": + if err := func() error { + s.TenKai.Reset() + if err := s.TenKai.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_kai\"") + } + case "aiten": + if err := func() error { + s.Aiten.Reset() + if err := s.Aiten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"aiten\"") + } + case "ten_card": + if err := func() error { + s.TenCard.Reset() + if err := s.TenCard.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_card\"") + } + case "ten_delete": + if err := func() error { + s.TenDelete.Reset() + if err := s.TenDelete.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_delete\"") + } + case "ten_post": + if err := func() error { + s.TenPost.Reset() + if err := s.TenPost.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_post\"") + } + case "ten_get": + if err := func() error { + s.TenGet.Reset() + if err := s.TenGet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_get\"") + } + case "ten_at": + if err := func() error { + s.TenAt.Reset() + if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_at\"") + } case "next": if err := func() error { s.Next.Reset() @@ -2233,8 +3001,10 @@ func (s *GroupUsersList) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ + for i, mask := range [3]uint8{ 0b00000011, + 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -3412,6 +4182,96 @@ func (s *UpdateUserReq) encodeFields(e *jx.Encoder) { s.UpdatedAt.Encode(e, json.EncodeDateTime) } } + { + if s.RaidAt.Set { + e.FieldStart("raid_at") + s.RaidAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Luck.Set { + e.FieldStart("luck") + s.Luck.Encode(e) + } + } + { + if s.LuckAt.Set { + e.FieldStart("luck_at") + s.LuckAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Like.Set { + e.FieldStart("like") + s.Like.Encode(e) + } + } + { + if s.LikeRank.Set { + e.FieldStart("like_rank") + s.LikeRank.Encode(e) + } + } + { + if s.LikeAt.Set { + e.FieldStart("like_at") + s.LikeAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Ten.Set { + e.FieldStart("ten") + s.Ten.Encode(e) + } + } + { + if s.TenSu.Set { + e.FieldStart("ten_su") + s.TenSu.Encode(e) + } + } + { + if s.TenKai.Set { + e.FieldStart("ten_kai") + s.TenKai.Encode(e) + } + } + { + if s.Aiten.Set { + e.FieldStart("aiten") + s.Aiten.Encode(e) + } + } + { + if s.TenCard.Set { + e.FieldStart("ten_card") + s.TenCard.Encode(e) + } + } + { + if s.TenDelete.Set { + e.FieldStart("ten_delete") + s.TenDelete.Encode(e) + } + } + { + if s.TenPost.Set { + e.FieldStart("ten_post") + s.TenPost.Encode(e) + } + } + { + if s.TenGet.Set { + e.FieldStart("ten_get") + s.TenGet.Encode(e) + } + } + { + if s.TenAt.Set { + e.FieldStart("ten_at") + s.TenAt.Encode(e, json.EncodeDateTime) + } + } { if s.Next.Set { e.FieldStart("next") @@ -3430,13 +4290,28 @@ func (s *UpdateUserReq) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfUpdateUserReq = [6]string{ - 0: "did", - 1: "delete", - 2: "token", - 3: "updated_at", - 4: "next", - 5: "card", +var jsonFieldsNameOfUpdateUserReq = [21]string{ + 0: "did", + 1: "delete", + 2: "token", + 3: "updated_at", + 4: "raid_at", + 5: "luck", + 6: "luck_at", + 7: "like", + 8: "like_rank", + 9: "like_at", + 10: "ten", + 11: "ten_su", + 12: "ten_kai", + 13: "aiten", + 14: "ten_card", + 15: "ten_delete", + 16: "ten_post", + 17: "ten_get", + 18: "ten_at", + 19: "next", + 20: "card", } // Decode decodes UpdateUserReq from json. @@ -3487,6 +4362,156 @@ func (s *UpdateUserReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } + case "raid_at": + if err := func() error { + s.RaidAt.Reset() + if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raid_at\"") + } + case "luck": + if err := func() error { + s.Luck.Reset() + if err := s.Luck.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck\"") + } + case "luck_at": + if err := func() error { + s.LuckAt.Reset() + if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck_at\"") + } + case "like": + if err := func() error { + s.Like.Reset() + if err := s.Like.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like\"") + } + case "like_rank": + if err := func() error { + s.LikeRank.Reset() + if err := s.LikeRank.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_rank\"") + } + case "like_at": + if err := func() error { + s.LikeAt.Reset() + if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_at\"") + } + case "ten": + if err := func() error { + s.Ten.Reset() + if err := s.Ten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten\"") + } + case "ten_su": + if err := func() error { + s.TenSu.Reset() + if err := s.TenSu.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_su\"") + } + case "ten_kai": + if err := func() error { + s.TenKai.Reset() + if err := s.TenKai.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_kai\"") + } + case "aiten": + if err := func() error { + s.Aiten.Reset() + if err := s.Aiten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"aiten\"") + } + case "ten_card": + if err := func() error { + s.TenCard.Reset() + if err := s.TenCard.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_card\"") + } + case "ten_delete": + if err := func() error { + s.TenDelete.Reset() + if err := s.TenDelete.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_delete\"") + } + case "ten_post": + if err := func() error { + s.TenPost.Reset() + if err := s.TenPost.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_post\"") + } + case "ten_get": + if err := func() error { + s.TenGet.Reset() + if err := s.TenGet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_get\"") + } + case "ten_at": + if err := func() error { + s.TenAt.Reset() + if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_at\"") + } case "next": if err := func() error { s.Next.Reset() @@ -3782,6 +4807,96 @@ func (s *UserCreate) encodeFields(e *jx.Encoder) { s.UpdatedAt.Encode(e, json.EncodeDateTime) } } + { + if s.RaidAt.Set { + e.FieldStart("raid_at") + s.RaidAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Luck.Set { + e.FieldStart("luck") + s.Luck.Encode(e) + } + } + { + if s.LuckAt.Set { + e.FieldStart("luck_at") + s.LuckAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Like.Set { + e.FieldStart("like") + s.Like.Encode(e) + } + } + { + if s.LikeRank.Set { + e.FieldStart("like_rank") + s.LikeRank.Encode(e) + } + } + { + if s.LikeAt.Set { + e.FieldStart("like_at") + s.LikeAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Ten.Set { + e.FieldStart("ten") + s.Ten.Encode(e) + } + } + { + if s.TenSu.Set { + e.FieldStart("ten_su") + s.TenSu.Encode(e) + } + } + { + if s.TenKai.Set { + e.FieldStart("ten_kai") + s.TenKai.Encode(e) + } + } + { + if s.Aiten.Set { + e.FieldStart("aiten") + s.Aiten.Encode(e) + } + } + { + if s.TenCard.Set { + e.FieldStart("ten_card") + s.TenCard.Encode(e) + } + } + { + if s.TenDelete.Set { + e.FieldStart("ten_delete") + s.TenDelete.Encode(e) + } + } + { + if s.TenPost.Set { + e.FieldStart("ten_post") + s.TenPost.Encode(e) + } + } + { + if s.TenGet.Set { + e.FieldStart("ten_get") + s.TenGet.Encode(e) + } + } + { + if s.TenAt.Set { + e.FieldStart("ten_at") + s.TenAt.Encode(e, json.EncodeDateTime) + } + } { if s.Next.Set { e.FieldStart("next") @@ -3790,14 +4905,29 @@ func (s *UserCreate) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfUserCreate = [7]string{ - 0: "id", - 1: "username", - 2: "did", - 3: "delete", - 4: "created_at", - 5: "updated_at", - 6: "next", +var jsonFieldsNameOfUserCreate = [22]string{ + 0: "id", + 1: "username", + 2: "did", + 3: "delete", + 4: "created_at", + 5: "updated_at", + 6: "raid_at", + 7: "luck", + 8: "luck_at", + 9: "like", + 10: "like_rank", + 11: "like_at", + 12: "ten", + 13: "ten_su", + 14: "ten_kai", + 15: "aiten", + 16: "ten_card", + 17: "ten_delete", + 18: "ten_post", + 19: "ten_get", + 20: "ten_at", + 21: "next", } // Decode decodes UserCreate from json. @@ -3805,7 +4935,7 @@ func (s *UserCreate) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode UserCreate to nil") } - var requiredBitSet [1]uint8 + var requiredBitSet [3]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -3873,6 +5003,156 @@ func (s *UserCreate) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } + case "raid_at": + if err := func() error { + s.RaidAt.Reset() + if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raid_at\"") + } + case "luck": + if err := func() error { + s.Luck.Reset() + if err := s.Luck.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck\"") + } + case "luck_at": + if err := func() error { + s.LuckAt.Reset() + if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck_at\"") + } + case "like": + if err := func() error { + s.Like.Reset() + if err := s.Like.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like\"") + } + case "like_rank": + if err := func() error { + s.LikeRank.Reset() + if err := s.LikeRank.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_rank\"") + } + case "like_at": + if err := func() error { + s.LikeAt.Reset() + if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_at\"") + } + case "ten": + if err := func() error { + s.Ten.Reset() + if err := s.Ten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten\"") + } + case "ten_su": + if err := func() error { + s.TenSu.Reset() + if err := s.TenSu.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_su\"") + } + case "ten_kai": + if err := func() error { + s.TenKai.Reset() + if err := s.TenKai.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_kai\"") + } + case "aiten": + if err := func() error { + s.Aiten.Reset() + if err := s.Aiten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"aiten\"") + } + case "ten_card": + if err := func() error { + s.TenCard.Reset() + if err := s.TenCard.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_card\"") + } + case "ten_delete": + if err := func() error { + s.TenDelete.Reset() + if err := s.TenDelete.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_delete\"") + } + case "ten_post": + if err := func() error { + s.TenPost.Reset() + if err := s.TenPost.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_post\"") + } + case "ten_get": + if err := func() error { + s.TenGet.Reset() + if err := s.TenGet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_get\"") + } + case "ten_at": + if err := func() error { + s.TenAt.Reset() + if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_at\"") + } case "next": if err := func() error { s.Next.Reset() @@ -3892,8 +5172,10 @@ func (s *UserCreate) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ + for i, mask := range [3]uint8{ 0b00000011, + 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -3982,6 +5264,96 @@ func (s *UserList) encodeFields(e *jx.Encoder) { s.UpdatedAt.Encode(e, json.EncodeDateTime) } } + { + if s.RaidAt.Set { + e.FieldStart("raid_at") + s.RaidAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Luck.Set { + e.FieldStart("luck") + s.Luck.Encode(e) + } + } + { + if s.LuckAt.Set { + e.FieldStart("luck_at") + s.LuckAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Like.Set { + e.FieldStart("like") + s.Like.Encode(e) + } + } + { + if s.LikeRank.Set { + e.FieldStart("like_rank") + s.LikeRank.Encode(e) + } + } + { + if s.LikeAt.Set { + e.FieldStart("like_at") + s.LikeAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Ten.Set { + e.FieldStart("ten") + s.Ten.Encode(e) + } + } + { + if s.TenSu.Set { + e.FieldStart("ten_su") + s.TenSu.Encode(e) + } + } + { + if s.TenKai.Set { + e.FieldStart("ten_kai") + s.TenKai.Encode(e) + } + } + { + if s.Aiten.Set { + e.FieldStart("aiten") + s.Aiten.Encode(e) + } + } + { + if s.TenCard.Set { + e.FieldStart("ten_card") + s.TenCard.Encode(e) + } + } + { + if s.TenDelete.Set { + e.FieldStart("ten_delete") + s.TenDelete.Encode(e) + } + } + { + if s.TenPost.Set { + e.FieldStart("ten_post") + s.TenPost.Encode(e) + } + } + { + if s.TenGet.Set { + e.FieldStart("ten_get") + s.TenGet.Encode(e) + } + } + { + if s.TenAt.Set { + e.FieldStart("ten_at") + s.TenAt.Encode(e, json.EncodeDateTime) + } + } { if s.Next.Set { e.FieldStart("next") @@ -3990,14 +5362,29 @@ func (s *UserList) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfUserList = [7]string{ - 0: "id", - 1: "username", - 2: "did", - 3: "delete", - 4: "created_at", - 5: "updated_at", - 6: "next", +var jsonFieldsNameOfUserList = [22]string{ + 0: "id", + 1: "username", + 2: "did", + 3: "delete", + 4: "created_at", + 5: "updated_at", + 6: "raid_at", + 7: "luck", + 8: "luck_at", + 9: "like", + 10: "like_rank", + 11: "like_at", + 12: "ten", + 13: "ten_su", + 14: "ten_kai", + 15: "aiten", + 16: "ten_card", + 17: "ten_delete", + 18: "ten_post", + 19: "ten_get", + 20: "ten_at", + 21: "next", } // Decode decodes UserList from json. @@ -4005,7 +5392,7 @@ func (s *UserList) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode UserList to nil") } - var requiredBitSet [1]uint8 + var requiredBitSet [3]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -4073,6 +5460,156 @@ func (s *UserList) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } + case "raid_at": + if err := func() error { + s.RaidAt.Reset() + if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raid_at\"") + } + case "luck": + if err := func() error { + s.Luck.Reset() + if err := s.Luck.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck\"") + } + case "luck_at": + if err := func() error { + s.LuckAt.Reset() + if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck_at\"") + } + case "like": + if err := func() error { + s.Like.Reset() + if err := s.Like.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like\"") + } + case "like_rank": + if err := func() error { + s.LikeRank.Reset() + if err := s.LikeRank.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_rank\"") + } + case "like_at": + if err := func() error { + s.LikeAt.Reset() + if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_at\"") + } + case "ten": + if err := func() error { + s.Ten.Reset() + if err := s.Ten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten\"") + } + case "ten_su": + if err := func() error { + s.TenSu.Reset() + if err := s.TenSu.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_su\"") + } + case "ten_kai": + if err := func() error { + s.TenKai.Reset() + if err := s.TenKai.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_kai\"") + } + case "aiten": + if err := func() error { + s.Aiten.Reset() + if err := s.Aiten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"aiten\"") + } + case "ten_card": + if err := func() error { + s.TenCard.Reset() + if err := s.TenCard.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_card\"") + } + case "ten_delete": + if err := func() error { + s.TenDelete.Reset() + if err := s.TenDelete.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_delete\"") + } + case "ten_post": + if err := func() error { + s.TenPost.Reset() + if err := s.TenPost.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_post\"") + } + case "ten_get": + if err := func() error { + s.TenGet.Reset() + if err := s.TenGet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_get\"") + } + case "ten_at": + if err := func() error { + s.TenAt.Reset() + if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_at\"") + } case "next": if err := func() error { s.Next.Reset() @@ -4092,8 +5629,10 @@ func (s *UserList) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ + for i, mask := range [3]uint8{ 0b00000011, + 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -4182,6 +5721,96 @@ func (s *UserRead) encodeFields(e *jx.Encoder) { s.UpdatedAt.Encode(e, json.EncodeDateTime) } } + { + if s.RaidAt.Set { + e.FieldStart("raid_at") + s.RaidAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Luck.Set { + e.FieldStart("luck") + s.Luck.Encode(e) + } + } + { + if s.LuckAt.Set { + e.FieldStart("luck_at") + s.LuckAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Like.Set { + e.FieldStart("like") + s.Like.Encode(e) + } + } + { + if s.LikeRank.Set { + e.FieldStart("like_rank") + s.LikeRank.Encode(e) + } + } + { + if s.LikeAt.Set { + e.FieldStart("like_at") + s.LikeAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Ten.Set { + e.FieldStart("ten") + s.Ten.Encode(e) + } + } + { + if s.TenSu.Set { + e.FieldStart("ten_su") + s.TenSu.Encode(e) + } + } + { + if s.TenKai.Set { + e.FieldStart("ten_kai") + s.TenKai.Encode(e) + } + } + { + if s.Aiten.Set { + e.FieldStart("aiten") + s.Aiten.Encode(e) + } + } + { + if s.TenCard.Set { + e.FieldStart("ten_card") + s.TenCard.Encode(e) + } + } + { + if s.TenDelete.Set { + e.FieldStart("ten_delete") + s.TenDelete.Encode(e) + } + } + { + if s.TenPost.Set { + e.FieldStart("ten_post") + s.TenPost.Encode(e) + } + } + { + if s.TenGet.Set { + e.FieldStart("ten_get") + s.TenGet.Encode(e) + } + } + { + if s.TenAt.Set { + e.FieldStart("ten_at") + s.TenAt.Encode(e, json.EncodeDateTime) + } + } { if s.Next.Set { e.FieldStart("next") @@ -4190,14 +5819,29 @@ func (s *UserRead) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfUserRead = [7]string{ - 0: "id", - 1: "username", - 2: "did", - 3: "delete", - 4: "created_at", - 5: "updated_at", - 6: "next", +var jsonFieldsNameOfUserRead = [22]string{ + 0: "id", + 1: "username", + 2: "did", + 3: "delete", + 4: "created_at", + 5: "updated_at", + 6: "raid_at", + 7: "luck", + 8: "luck_at", + 9: "like", + 10: "like_rank", + 11: "like_at", + 12: "ten", + 13: "ten_su", + 14: "ten_kai", + 15: "aiten", + 16: "ten_card", + 17: "ten_delete", + 18: "ten_post", + 19: "ten_get", + 20: "ten_at", + 21: "next", } // Decode decodes UserRead from json. @@ -4205,7 +5849,7 @@ func (s *UserRead) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode UserRead to nil") } - var requiredBitSet [1]uint8 + var requiredBitSet [3]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -4273,6 +5917,156 @@ func (s *UserRead) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } + case "raid_at": + if err := func() error { + s.RaidAt.Reset() + if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raid_at\"") + } + case "luck": + if err := func() error { + s.Luck.Reset() + if err := s.Luck.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck\"") + } + case "luck_at": + if err := func() error { + s.LuckAt.Reset() + if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck_at\"") + } + case "like": + if err := func() error { + s.Like.Reset() + if err := s.Like.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like\"") + } + case "like_rank": + if err := func() error { + s.LikeRank.Reset() + if err := s.LikeRank.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_rank\"") + } + case "like_at": + if err := func() error { + s.LikeAt.Reset() + if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_at\"") + } + case "ten": + if err := func() error { + s.Ten.Reset() + if err := s.Ten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten\"") + } + case "ten_su": + if err := func() error { + s.TenSu.Reset() + if err := s.TenSu.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_su\"") + } + case "ten_kai": + if err := func() error { + s.TenKai.Reset() + if err := s.TenKai.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_kai\"") + } + case "aiten": + if err := func() error { + s.Aiten.Reset() + if err := s.Aiten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"aiten\"") + } + case "ten_card": + if err := func() error { + s.TenCard.Reset() + if err := s.TenCard.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_card\"") + } + case "ten_delete": + if err := func() error { + s.TenDelete.Reset() + if err := s.TenDelete.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_delete\"") + } + case "ten_post": + if err := func() error { + s.TenPost.Reset() + if err := s.TenPost.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_post\"") + } + case "ten_get": + if err := func() error { + s.TenGet.Reset() + if err := s.TenGet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_get\"") + } + case "ten_at": + if err := func() error { + s.TenAt.Reset() + if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_at\"") + } case "next": if err := func() error { s.Next.Reset() @@ -4292,8 +6086,10 @@ func (s *UserRead) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ + for i, mask := range [3]uint8{ 0b00000011, + 0b00000000, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -4382,6 +6178,96 @@ func (s *UserUpdate) encodeFields(e *jx.Encoder) { s.UpdatedAt.Encode(e, json.EncodeDateTime) } } + { + if s.RaidAt.Set { + e.FieldStart("raid_at") + s.RaidAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Luck.Set { + e.FieldStart("luck") + s.Luck.Encode(e) + } + } + { + if s.LuckAt.Set { + e.FieldStart("luck_at") + s.LuckAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Like.Set { + e.FieldStart("like") + s.Like.Encode(e) + } + } + { + if s.LikeRank.Set { + e.FieldStart("like_rank") + s.LikeRank.Encode(e) + } + } + { + if s.LikeAt.Set { + e.FieldStart("like_at") + s.LikeAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.Ten.Set { + e.FieldStart("ten") + s.Ten.Encode(e) + } + } + { + if s.TenSu.Set { + e.FieldStart("ten_su") + s.TenSu.Encode(e) + } + } + { + if s.TenKai.Set { + e.FieldStart("ten_kai") + s.TenKai.Encode(e) + } + } + { + if s.Aiten.Set { + e.FieldStart("aiten") + s.Aiten.Encode(e) + } + } + { + if s.TenCard.Set { + e.FieldStart("ten_card") + s.TenCard.Encode(e) + } + } + { + if s.TenDelete.Set { + e.FieldStart("ten_delete") + s.TenDelete.Encode(e) + } + } + { + if s.TenPost.Set { + e.FieldStart("ten_post") + s.TenPost.Encode(e) + } + } + { + if s.TenGet.Set { + e.FieldStart("ten_get") + s.TenGet.Encode(e) + } + } + { + if s.TenAt.Set { + e.FieldStart("ten_at") + s.TenAt.Encode(e, json.EncodeDateTime) + } + } { if s.Next.Set { e.FieldStart("next") @@ -4390,14 +6276,29 @@ func (s *UserUpdate) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfUserUpdate = [7]string{ - 0: "id", - 1: "username", - 2: "did", - 3: "delete", - 4: "created_at", - 5: "updated_at", - 6: "next", +var jsonFieldsNameOfUserUpdate = [22]string{ + 0: "id", + 1: "username", + 2: "did", + 3: "delete", + 4: "created_at", + 5: "updated_at", + 6: "raid_at", + 7: "luck", + 8: "luck_at", + 9: "like", + 10: "like_rank", + 11: "like_at", + 12: "ten", + 13: "ten_su", + 14: "ten_kai", + 15: "aiten", + 16: "ten_card", + 17: "ten_delete", + 18: "ten_post", + 19: "ten_get", + 20: "ten_at", + 21: "next", } // Decode decodes UserUpdate from json. @@ -4405,7 +6306,7 @@ func (s *UserUpdate) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode UserUpdate to nil") } - var requiredBitSet [1]uint8 + var requiredBitSet [3]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -4473,6 +6374,156 @@ func (s *UserUpdate) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"updated_at\"") } + case "raid_at": + if err := func() error { + s.RaidAt.Reset() + if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raid_at\"") + } + case "luck": + if err := func() error { + s.Luck.Reset() + if err := s.Luck.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck\"") + } + case "luck_at": + if err := func() error { + s.LuckAt.Reset() + if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"luck_at\"") + } + case "like": + if err := func() error { + s.Like.Reset() + if err := s.Like.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like\"") + } + case "like_rank": + if err := func() error { + s.LikeRank.Reset() + if err := s.LikeRank.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_rank\"") + } + case "like_at": + if err := func() error { + s.LikeAt.Reset() + if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"like_at\"") + } + case "ten": + if err := func() error { + s.Ten.Reset() + if err := s.Ten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten\"") + } + case "ten_su": + if err := func() error { + s.TenSu.Reset() + if err := s.TenSu.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_su\"") + } + case "ten_kai": + if err := func() error { + s.TenKai.Reset() + if err := s.TenKai.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_kai\"") + } + case "aiten": + if err := func() error { + s.Aiten.Reset() + if err := s.Aiten.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"aiten\"") + } + case "ten_card": + if err := func() error { + s.TenCard.Reset() + if err := s.TenCard.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_card\"") + } + case "ten_delete": + if err := func() error { + s.TenDelete.Reset() + if err := s.TenDelete.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_delete\"") + } + case "ten_post": + if err := func() error { + s.TenPost.Reset() + if err := s.TenPost.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_post\"") + } + case "ten_get": + if err := func() error { + s.TenGet.Reset() + if err := s.TenGet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_get\"") + } + case "ten_at": + if err := func() error { + s.TenAt.Reset() + if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ten_at\"") + } case "next": if err := func() error { s.Next.Reset() @@ -4492,8 +6543,10 @@ func (s *UserUpdate) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ + for i, mask := range [3]uint8{ 0b00000011, + 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_parameters_gen.go b/ent/ogent/oas_parameters_gen.go index 127c6f7..c9ce70c 100644 --- a/ent/ogent/oas_parameters_gen.go +++ b/ent/ogent/oas_parameters_gen.go @@ -459,7 +459,7 @@ func decodeListCardParams(args [0]string, r *http.Request) (params ListCardParam MinSet: true, Min: 1, MaxSet: true, - Max: 3500, + Max: 4000, MinExclusive: false, MaxExclusive: false, MultipleOfSet: false, @@ -624,7 +624,7 @@ func decodeListGroupParams(args [0]string, r *http.Request) (params ListGroupPar MinSet: true, Min: 1, MaxSet: true, - Max: 3500, + Max: 4000, MinExclusive: false, MaxExclusive: false, MultipleOfSet: false, @@ -956,7 +956,7 @@ func decodeListUserParams(args [0]string, r *http.Request) (params ListUserParam MinSet: true, Min: 1, MaxSet: true, - Max: 3500, + Max: 4000, MinExclusive: false, MaxExclusive: false, MultipleOfSet: false, diff --git a/ent/ogent/oas_schemas_gen.go b/ent/ogent/oas_schemas_gen.go index b0423ba..baf1ba3 100644 --- a/ent/ogent/oas_schemas_gen.go +++ b/ent/ogent/oas_schemas_gen.go @@ -180,6 +180,21 @@ type CardOwnerRead struct { Delete OptBool `json:"delete"` CreatedAt OptDateTime `json:"created_at"` UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + 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"` } @@ -213,6 +228,81 @@ func (s *CardOwnerRead) GetUpdatedAt() OptDateTime { return s.UpdatedAt } +// GetRaidAt returns the value of RaidAt. +func (s *CardOwnerRead) GetRaidAt() OptDateTime { + return s.RaidAt +} + +// GetLuck returns the value of Luck. +func (s *CardOwnerRead) GetLuck() OptInt { + return s.Luck +} + +// GetLuckAt returns the value of LuckAt. +func (s *CardOwnerRead) GetLuckAt() OptDateTime { + return s.LuckAt +} + +// GetLike returns the value of Like. +func (s *CardOwnerRead) GetLike() OptInt { + return s.Like +} + +// GetLikeRank returns the value of LikeRank. +func (s *CardOwnerRead) GetLikeRank() OptInt { + return s.LikeRank +} + +// GetLikeAt returns the value of LikeAt. +func (s *CardOwnerRead) GetLikeAt() OptDateTime { + return s.LikeAt +} + +// GetTen returns the value of Ten. +func (s *CardOwnerRead) GetTen() OptBool { + return s.Ten +} + +// GetTenSu returns the value of TenSu. +func (s *CardOwnerRead) GetTenSu() OptInt { + return s.TenSu +} + +// GetTenKai returns the value of TenKai. +func (s *CardOwnerRead) GetTenKai() OptInt { + return s.TenKai +} + +// GetAiten returns the value of Aiten. +func (s *CardOwnerRead) GetAiten() OptInt { + return s.Aiten +} + +// GetTenCard returns the value of TenCard. +func (s *CardOwnerRead) GetTenCard() OptString { + return s.TenCard +} + +// GetTenDelete returns the value of TenDelete. +func (s *CardOwnerRead) GetTenDelete() OptString { + return s.TenDelete +} + +// GetTenPost returns the value of TenPost. +func (s *CardOwnerRead) GetTenPost() OptString { + return s.TenPost +} + +// GetTenGet returns the value of TenGet. +func (s *CardOwnerRead) GetTenGet() OptString { + return s.TenGet +} + +// GetTenAt returns the value of TenAt. +func (s *CardOwnerRead) GetTenAt() OptDateTime { + return s.TenAt +} + // GetNext returns the value of Next. func (s *CardOwnerRead) GetNext() OptString { return s.Next @@ -248,6 +338,81 @@ func (s *CardOwnerRead) SetUpdatedAt(val OptDateTime) { s.UpdatedAt = val } +// SetRaidAt sets the value of RaidAt. +func (s *CardOwnerRead) SetRaidAt(val OptDateTime) { + s.RaidAt = val +} + +// SetLuck sets the value of Luck. +func (s *CardOwnerRead) SetLuck(val OptInt) { + s.Luck = val +} + +// SetLuckAt sets the value of LuckAt. +func (s *CardOwnerRead) SetLuckAt(val OptDateTime) { + s.LuckAt = val +} + +// SetLike sets the value of Like. +func (s *CardOwnerRead) SetLike(val OptInt) { + s.Like = val +} + +// SetLikeRank sets the value of LikeRank. +func (s *CardOwnerRead) SetLikeRank(val OptInt) { + s.LikeRank = val +} + +// SetLikeAt sets the value of LikeAt. +func (s *CardOwnerRead) SetLikeAt(val OptDateTime) { + s.LikeAt = val +} + +// SetTen sets the value of Ten. +func (s *CardOwnerRead) SetTen(val OptBool) { + s.Ten = val +} + +// SetTenSu sets the value of TenSu. +func (s *CardOwnerRead) SetTenSu(val OptInt) { + s.TenSu = val +} + +// SetTenKai sets the value of TenKai. +func (s *CardOwnerRead) SetTenKai(val OptInt) { + s.TenKai = val +} + +// SetAiten sets the value of Aiten. +func (s *CardOwnerRead) SetAiten(val OptInt) { + s.Aiten = val +} + +// SetTenCard sets the value of TenCard. +func (s *CardOwnerRead) SetTenCard(val OptString) { + s.TenCard = val +} + +// SetTenDelete sets the value of TenDelete. +func (s *CardOwnerRead) SetTenDelete(val OptString) { + s.TenDelete = val +} + +// SetTenPost sets the value of TenPost. +func (s *CardOwnerRead) SetTenPost(val OptString) { + s.TenPost = val +} + +// SetTenGet sets the value of TenGet. +func (s *CardOwnerRead) SetTenGet(val OptString) { + s.TenGet = val +} + +// SetTenAt sets the value of TenAt. +func (s *CardOwnerRead) SetTenAt(val OptDateTime) { + s.TenAt = val +} + // SetNext sets the value of Next. func (s *CardOwnerRead) SetNext(val OptString) { s.Next = val @@ -556,6 +721,21 @@ type CreateUserReq struct { Password string `json:"password"` CreatedAt OptDateTime `json:"created_at"` UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + 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"` Card []int `json:"card"` } @@ -595,6 +775,81 @@ func (s *CreateUserReq) GetUpdatedAt() OptDateTime { return s.UpdatedAt } +// GetRaidAt returns the value of RaidAt. +func (s *CreateUserReq) GetRaidAt() OptDateTime { + return s.RaidAt +} + +// GetLuck returns the value of Luck. +func (s *CreateUserReq) GetLuck() OptInt { + return s.Luck +} + +// GetLuckAt returns the value of LuckAt. +func (s *CreateUserReq) GetLuckAt() OptDateTime { + return s.LuckAt +} + +// GetLike returns the value of Like. +func (s *CreateUserReq) GetLike() OptInt { + return s.Like +} + +// GetLikeRank returns the value of LikeRank. +func (s *CreateUserReq) GetLikeRank() OptInt { + return s.LikeRank +} + +// GetLikeAt returns the value of LikeAt. +func (s *CreateUserReq) GetLikeAt() OptDateTime { + return s.LikeAt +} + +// GetTen returns the value of Ten. +func (s *CreateUserReq) GetTen() OptBool { + return s.Ten +} + +// GetTenSu returns the value of TenSu. +func (s *CreateUserReq) GetTenSu() OptInt { + return s.TenSu +} + +// GetTenKai returns the value of TenKai. +func (s *CreateUserReq) GetTenKai() OptInt { + return s.TenKai +} + +// GetAiten returns the value of Aiten. +func (s *CreateUserReq) GetAiten() OptInt { + return s.Aiten +} + +// GetTenCard returns the value of TenCard. +func (s *CreateUserReq) GetTenCard() OptString { + return s.TenCard +} + +// GetTenDelete returns the value of TenDelete. +func (s *CreateUserReq) GetTenDelete() OptString { + return s.TenDelete +} + +// GetTenPost returns the value of TenPost. +func (s *CreateUserReq) GetTenPost() OptString { + return s.TenPost +} + +// GetTenGet returns the value of TenGet. +func (s *CreateUserReq) GetTenGet() OptString { + return s.TenGet +} + +// GetTenAt returns the value of TenAt. +func (s *CreateUserReq) GetTenAt() OptDateTime { + return s.TenAt +} + // GetNext returns the value of Next. func (s *CreateUserReq) GetNext() OptString { return s.Next @@ -640,6 +895,81 @@ func (s *CreateUserReq) SetUpdatedAt(val OptDateTime) { s.UpdatedAt = val } +// SetRaidAt sets the value of RaidAt. +func (s *CreateUserReq) SetRaidAt(val OptDateTime) { + s.RaidAt = val +} + +// SetLuck sets the value of Luck. +func (s *CreateUserReq) SetLuck(val OptInt) { + s.Luck = val +} + +// SetLuckAt sets the value of LuckAt. +func (s *CreateUserReq) SetLuckAt(val OptDateTime) { + s.LuckAt = val +} + +// SetLike sets the value of Like. +func (s *CreateUserReq) SetLike(val OptInt) { + s.Like = val +} + +// SetLikeRank sets the value of LikeRank. +func (s *CreateUserReq) SetLikeRank(val OptInt) { + s.LikeRank = val +} + +// SetLikeAt sets the value of LikeAt. +func (s *CreateUserReq) SetLikeAt(val OptDateTime) { + s.LikeAt = val +} + +// SetTen sets the value of Ten. +func (s *CreateUserReq) SetTen(val OptBool) { + s.Ten = val +} + +// SetTenSu sets the value of TenSu. +func (s *CreateUserReq) SetTenSu(val OptInt) { + s.TenSu = val +} + +// SetTenKai sets the value of TenKai. +func (s *CreateUserReq) SetTenKai(val OptInt) { + s.TenKai = val +} + +// SetAiten sets the value of Aiten. +func (s *CreateUserReq) SetAiten(val OptInt) { + s.Aiten = val +} + +// SetTenCard sets the value of TenCard. +func (s *CreateUserReq) SetTenCard(val OptString) { + s.TenCard = val +} + +// SetTenDelete sets the value of TenDelete. +func (s *CreateUserReq) SetTenDelete(val OptString) { + s.TenDelete = val +} + +// SetTenPost sets the value of TenPost. +func (s *CreateUserReq) SetTenPost(val OptString) { + s.TenPost = val +} + +// SetTenGet sets the value of TenGet. +func (s *CreateUserReq) SetTenGet(val OptString) { + s.TenGet = val +} + +// SetTenAt sets the value of TenAt. +func (s *CreateUserReq) SetTenAt(val OptDateTime) { + s.TenAt = val +} + // SetNext sets the value of Next. func (s *CreateUserReq) SetNext(val OptString) { s.Next = val @@ -789,6 +1119,21 @@ type GroupUsersList struct { Delete OptBool `json:"delete"` CreatedAt OptDateTime `json:"created_at"` UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + 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"` } @@ -822,6 +1167,81 @@ func (s *GroupUsersList) GetUpdatedAt() OptDateTime { return s.UpdatedAt } +// GetRaidAt returns the value of RaidAt. +func (s *GroupUsersList) GetRaidAt() OptDateTime { + return s.RaidAt +} + +// GetLuck returns the value of Luck. +func (s *GroupUsersList) GetLuck() OptInt { + return s.Luck +} + +// GetLuckAt returns the value of LuckAt. +func (s *GroupUsersList) GetLuckAt() OptDateTime { + return s.LuckAt +} + +// GetLike returns the value of Like. +func (s *GroupUsersList) GetLike() OptInt { + return s.Like +} + +// GetLikeRank returns the value of LikeRank. +func (s *GroupUsersList) GetLikeRank() OptInt { + return s.LikeRank +} + +// GetLikeAt returns the value of LikeAt. +func (s *GroupUsersList) GetLikeAt() OptDateTime { + return s.LikeAt +} + +// GetTen returns the value of Ten. +func (s *GroupUsersList) GetTen() OptBool { + return s.Ten +} + +// GetTenSu returns the value of TenSu. +func (s *GroupUsersList) GetTenSu() OptInt { + return s.TenSu +} + +// GetTenKai returns the value of TenKai. +func (s *GroupUsersList) GetTenKai() OptInt { + return s.TenKai +} + +// GetAiten returns the value of Aiten. +func (s *GroupUsersList) GetAiten() OptInt { + return s.Aiten +} + +// GetTenCard returns the value of TenCard. +func (s *GroupUsersList) GetTenCard() OptString { + return s.TenCard +} + +// GetTenDelete returns the value of TenDelete. +func (s *GroupUsersList) GetTenDelete() OptString { + return s.TenDelete +} + +// GetTenPost returns the value of TenPost. +func (s *GroupUsersList) GetTenPost() OptString { + return s.TenPost +} + +// GetTenGet returns the value of TenGet. +func (s *GroupUsersList) GetTenGet() OptString { + return s.TenGet +} + +// GetTenAt returns the value of TenAt. +func (s *GroupUsersList) GetTenAt() OptDateTime { + return s.TenAt +} + // GetNext returns the value of Next. func (s *GroupUsersList) GetNext() OptString { return s.Next @@ -857,6 +1277,81 @@ func (s *GroupUsersList) SetUpdatedAt(val OptDateTime) { s.UpdatedAt = val } +// SetRaidAt sets the value of RaidAt. +func (s *GroupUsersList) SetRaidAt(val OptDateTime) { + s.RaidAt = val +} + +// SetLuck sets the value of Luck. +func (s *GroupUsersList) SetLuck(val OptInt) { + s.Luck = val +} + +// SetLuckAt sets the value of LuckAt. +func (s *GroupUsersList) SetLuckAt(val OptDateTime) { + s.LuckAt = val +} + +// SetLike sets the value of Like. +func (s *GroupUsersList) SetLike(val OptInt) { + s.Like = val +} + +// SetLikeRank sets the value of LikeRank. +func (s *GroupUsersList) SetLikeRank(val OptInt) { + s.LikeRank = val +} + +// SetLikeAt sets the value of LikeAt. +func (s *GroupUsersList) SetLikeAt(val OptDateTime) { + s.LikeAt = val +} + +// SetTen sets the value of Ten. +func (s *GroupUsersList) SetTen(val OptBool) { + s.Ten = val +} + +// SetTenSu sets the value of TenSu. +func (s *GroupUsersList) SetTenSu(val OptInt) { + s.TenSu = val +} + +// SetTenKai sets the value of TenKai. +func (s *GroupUsersList) SetTenKai(val OptInt) { + s.TenKai = val +} + +// SetAiten sets the value of Aiten. +func (s *GroupUsersList) SetAiten(val OptInt) { + s.Aiten = val +} + +// SetTenCard sets the value of TenCard. +func (s *GroupUsersList) SetTenCard(val OptString) { + s.TenCard = val +} + +// SetTenDelete sets the value of TenDelete. +func (s *GroupUsersList) SetTenDelete(val OptString) { + s.TenDelete = val +} + +// SetTenPost sets the value of TenPost. +func (s *GroupUsersList) SetTenPost(val OptString) { + s.TenPost = val +} + +// SetTenGet sets the value of TenGet. +func (s *GroupUsersList) SetTenGet(val OptString) { + s.TenGet = val +} + +// SetTenAt sets the value of TenAt. +func (s *GroupUsersList) SetTenAt(val OptDateTime) { + s.TenAt = val +} + // SetNext sets the value of Next. func (s *GroupUsersList) SetNext(val OptString) { s.Next = val @@ -1338,6 +1833,21 @@ type UpdateUserReq struct { Delete OptBool `json:"delete"` Token OptString `json:"token"` UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + 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"` Card []int `json:"card"` } @@ -1362,6 +1872,81 @@ func (s *UpdateUserReq) GetUpdatedAt() OptDateTime { return s.UpdatedAt } +// GetRaidAt returns the value of RaidAt. +func (s *UpdateUserReq) GetRaidAt() OptDateTime { + return s.RaidAt +} + +// GetLuck returns the value of Luck. +func (s *UpdateUserReq) GetLuck() OptInt { + return s.Luck +} + +// GetLuckAt returns the value of LuckAt. +func (s *UpdateUserReq) GetLuckAt() OptDateTime { + return s.LuckAt +} + +// GetLike returns the value of Like. +func (s *UpdateUserReq) GetLike() OptInt { + return s.Like +} + +// GetLikeRank returns the value of LikeRank. +func (s *UpdateUserReq) GetLikeRank() OptInt { + return s.LikeRank +} + +// GetLikeAt returns the value of LikeAt. +func (s *UpdateUserReq) GetLikeAt() OptDateTime { + return s.LikeAt +} + +// GetTen returns the value of Ten. +func (s *UpdateUserReq) GetTen() OptBool { + return s.Ten +} + +// GetTenSu returns the value of TenSu. +func (s *UpdateUserReq) GetTenSu() OptInt { + return s.TenSu +} + +// GetTenKai returns the value of TenKai. +func (s *UpdateUserReq) GetTenKai() OptInt { + return s.TenKai +} + +// GetAiten returns the value of Aiten. +func (s *UpdateUserReq) GetAiten() OptInt { + return s.Aiten +} + +// GetTenCard returns the value of TenCard. +func (s *UpdateUserReq) GetTenCard() OptString { + return s.TenCard +} + +// GetTenDelete returns the value of TenDelete. +func (s *UpdateUserReq) GetTenDelete() OptString { + return s.TenDelete +} + +// GetTenPost returns the value of TenPost. +func (s *UpdateUserReq) GetTenPost() OptString { + return s.TenPost +} + +// GetTenGet returns the value of TenGet. +func (s *UpdateUserReq) GetTenGet() OptString { + return s.TenGet +} + +// GetTenAt returns the value of TenAt. +func (s *UpdateUserReq) GetTenAt() OptDateTime { + return s.TenAt +} + // GetNext returns the value of Next. func (s *UpdateUserReq) GetNext() OptString { return s.Next @@ -1392,6 +1977,81 @@ func (s *UpdateUserReq) SetUpdatedAt(val OptDateTime) { s.UpdatedAt = val } +// SetRaidAt sets the value of RaidAt. +func (s *UpdateUserReq) SetRaidAt(val OptDateTime) { + s.RaidAt = val +} + +// SetLuck sets the value of Luck. +func (s *UpdateUserReq) SetLuck(val OptInt) { + s.Luck = val +} + +// SetLuckAt sets the value of LuckAt. +func (s *UpdateUserReq) SetLuckAt(val OptDateTime) { + s.LuckAt = val +} + +// SetLike sets the value of Like. +func (s *UpdateUserReq) SetLike(val OptInt) { + s.Like = val +} + +// SetLikeRank sets the value of LikeRank. +func (s *UpdateUserReq) SetLikeRank(val OptInt) { + s.LikeRank = val +} + +// SetLikeAt sets the value of LikeAt. +func (s *UpdateUserReq) SetLikeAt(val OptDateTime) { + s.LikeAt = val +} + +// SetTen sets the value of Ten. +func (s *UpdateUserReq) SetTen(val OptBool) { + s.Ten = val +} + +// SetTenSu sets the value of TenSu. +func (s *UpdateUserReq) SetTenSu(val OptInt) { + s.TenSu = val +} + +// SetTenKai sets the value of TenKai. +func (s *UpdateUserReq) SetTenKai(val OptInt) { + s.TenKai = val +} + +// SetAiten sets the value of Aiten. +func (s *UpdateUserReq) SetAiten(val OptInt) { + s.Aiten = val +} + +// SetTenCard sets the value of TenCard. +func (s *UpdateUserReq) SetTenCard(val OptString) { + s.TenCard = val +} + +// SetTenDelete sets the value of TenDelete. +func (s *UpdateUserReq) SetTenDelete(val OptString) { + s.TenDelete = val +} + +// SetTenPost sets the value of TenPost. +func (s *UpdateUserReq) SetTenPost(val OptString) { + s.TenPost = val +} + +// SetTenGet sets the value of TenGet. +func (s *UpdateUserReq) SetTenGet(val OptString) { + s.TenGet = val +} + +// SetTenAt sets the value of TenAt. +func (s *UpdateUserReq) SetTenAt(val OptDateTime) { + s.TenAt = val +} + // SetNext sets the value of Next. func (s *UpdateUserReq) SetNext(val OptString) { s.Next = val @@ -1491,6 +2151,21 @@ type UserCreate struct { Delete OptBool `json:"delete"` CreatedAt OptDateTime `json:"created_at"` UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + 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"` } @@ -1524,6 +2199,81 @@ func (s *UserCreate) GetUpdatedAt() OptDateTime { return s.UpdatedAt } +// GetRaidAt returns the value of RaidAt. +func (s *UserCreate) GetRaidAt() OptDateTime { + return s.RaidAt +} + +// GetLuck returns the value of Luck. +func (s *UserCreate) GetLuck() OptInt { + return s.Luck +} + +// GetLuckAt returns the value of LuckAt. +func (s *UserCreate) GetLuckAt() OptDateTime { + return s.LuckAt +} + +// GetLike returns the value of Like. +func (s *UserCreate) GetLike() OptInt { + return s.Like +} + +// GetLikeRank returns the value of LikeRank. +func (s *UserCreate) GetLikeRank() OptInt { + return s.LikeRank +} + +// GetLikeAt returns the value of LikeAt. +func (s *UserCreate) GetLikeAt() OptDateTime { + return s.LikeAt +} + +// GetTen returns the value of Ten. +func (s *UserCreate) GetTen() OptBool { + return s.Ten +} + +// GetTenSu returns the value of TenSu. +func (s *UserCreate) GetTenSu() OptInt { + return s.TenSu +} + +// GetTenKai returns the value of TenKai. +func (s *UserCreate) GetTenKai() OptInt { + return s.TenKai +} + +// GetAiten returns the value of Aiten. +func (s *UserCreate) GetAiten() OptInt { + return s.Aiten +} + +// GetTenCard returns the value of TenCard. +func (s *UserCreate) GetTenCard() OptString { + return s.TenCard +} + +// GetTenDelete returns the value of TenDelete. +func (s *UserCreate) GetTenDelete() OptString { + return s.TenDelete +} + +// GetTenPost returns the value of TenPost. +func (s *UserCreate) GetTenPost() OptString { + return s.TenPost +} + +// GetTenGet returns the value of TenGet. +func (s *UserCreate) GetTenGet() OptString { + return s.TenGet +} + +// GetTenAt returns the value of TenAt. +func (s *UserCreate) GetTenAt() OptDateTime { + return s.TenAt +} + // GetNext returns the value of Next. func (s *UserCreate) GetNext() OptString { return s.Next @@ -1559,6 +2309,81 @@ func (s *UserCreate) SetUpdatedAt(val OptDateTime) { s.UpdatedAt = val } +// SetRaidAt sets the value of RaidAt. +func (s *UserCreate) SetRaidAt(val OptDateTime) { + s.RaidAt = val +} + +// SetLuck sets the value of Luck. +func (s *UserCreate) SetLuck(val OptInt) { + s.Luck = val +} + +// SetLuckAt sets the value of LuckAt. +func (s *UserCreate) SetLuckAt(val OptDateTime) { + s.LuckAt = val +} + +// SetLike sets the value of Like. +func (s *UserCreate) SetLike(val OptInt) { + s.Like = val +} + +// SetLikeRank sets the value of LikeRank. +func (s *UserCreate) SetLikeRank(val OptInt) { + s.LikeRank = val +} + +// SetLikeAt sets the value of LikeAt. +func (s *UserCreate) SetLikeAt(val OptDateTime) { + s.LikeAt = val +} + +// SetTen sets the value of Ten. +func (s *UserCreate) SetTen(val OptBool) { + s.Ten = val +} + +// SetTenSu sets the value of TenSu. +func (s *UserCreate) SetTenSu(val OptInt) { + s.TenSu = val +} + +// SetTenKai sets the value of TenKai. +func (s *UserCreate) SetTenKai(val OptInt) { + s.TenKai = val +} + +// SetAiten sets the value of Aiten. +func (s *UserCreate) SetAiten(val OptInt) { + s.Aiten = val +} + +// SetTenCard sets the value of TenCard. +func (s *UserCreate) SetTenCard(val OptString) { + s.TenCard = val +} + +// SetTenDelete sets the value of TenDelete. +func (s *UserCreate) SetTenDelete(val OptString) { + s.TenDelete = val +} + +// SetTenPost sets the value of TenPost. +func (s *UserCreate) SetTenPost(val OptString) { + s.TenPost = val +} + +// SetTenGet sets the value of TenGet. +func (s *UserCreate) SetTenGet(val OptString) { + s.TenGet = val +} + +// SetTenAt sets the value of TenAt. +func (s *UserCreate) SetTenAt(val OptDateTime) { + s.TenAt = val +} + // SetNext sets the value of Next. func (s *UserCreate) SetNext(val OptString) { s.Next = val @@ -1574,6 +2399,21 @@ type UserList struct { Delete OptBool `json:"delete"` CreatedAt OptDateTime `json:"created_at"` UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + 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"` } @@ -1607,6 +2447,81 @@ func (s *UserList) GetUpdatedAt() OptDateTime { return s.UpdatedAt } +// GetRaidAt returns the value of RaidAt. +func (s *UserList) GetRaidAt() OptDateTime { + return s.RaidAt +} + +// GetLuck returns the value of Luck. +func (s *UserList) GetLuck() OptInt { + return s.Luck +} + +// GetLuckAt returns the value of LuckAt. +func (s *UserList) GetLuckAt() OptDateTime { + return s.LuckAt +} + +// GetLike returns the value of Like. +func (s *UserList) GetLike() OptInt { + return s.Like +} + +// GetLikeRank returns the value of LikeRank. +func (s *UserList) GetLikeRank() OptInt { + return s.LikeRank +} + +// GetLikeAt returns the value of LikeAt. +func (s *UserList) GetLikeAt() OptDateTime { + return s.LikeAt +} + +// GetTen returns the value of Ten. +func (s *UserList) GetTen() OptBool { + return s.Ten +} + +// GetTenSu returns the value of TenSu. +func (s *UserList) GetTenSu() OptInt { + return s.TenSu +} + +// GetTenKai returns the value of TenKai. +func (s *UserList) GetTenKai() OptInt { + return s.TenKai +} + +// GetAiten returns the value of Aiten. +func (s *UserList) GetAiten() OptInt { + return s.Aiten +} + +// GetTenCard returns the value of TenCard. +func (s *UserList) GetTenCard() OptString { + return s.TenCard +} + +// GetTenDelete returns the value of TenDelete. +func (s *UserList) GetTenDelete() OptString { + return s.TenDelete +} + +// GetTenPost returns the value of TenPost. +func (s *UserList) GetTenPost() OptString { + return s.TenPost +} + +// GetTenGet returns the value of TenGet. +func (s *UserList) GetTenGet() OptString { + return s.TenGet +} + +// GetTenAt returns the value of TenAt. +func (s *UserList) GetTenAt() OptDateTime { + return s.TenAt +} + // GetNext returns the value of Next. func (s *UserList) GetNext() OptString { return s.Next @@ -1642,6 +2557,81 @@ func (s *UserList) SetUpdatedAt(val OptDateTime) { s.UpdatedAt = val } +// SetRaidAt sets the value of RaidAt. +func (s *UserList) SetRaidAt(val OptDateTime) { + s.RaidAt = val +} + +// SetLuck sets the value of Luck. +func (s *UserList) SetLuck(val OptInt) { + s.Luck = val +} + +// SetLuckAt sets the value of LuckAt. +func (s *UserList) SetLuckAt(val OptDateTime) { + s.LuckAt = val +} + +// SetLike sets the value of Like. +func (s *UserList) SetLike(val OptInt) { + s.Like = val +} + +// SetLikeRank sets the value of LikeRank. +func (s *UserList) SetLikeRank(val OptInt) { + s.LikeRank = val +} + +// SetLikeAt sets the value of LikeAt. +func (s *UserList) SetLikeAt(val OptDateTime) { + s.LikeAt = val +} + +// SetTen sets the value of Ten. +func (s *UserList) SetTen(val OptBool) { + s.Ten = val +} + +// SetTenSu sets the value of TenSu. +func (s *UserList) SetTenSu(val OptInt) { + s.TenSu = val +} + +// SetTenKai sets the value of TenKai. +func (s *UserList) SetTenKai(val OptInt) { + s.TenKai = val +} + +// SetAiten sets the value of Aiten. +func (s *UserList) SetAiten(val OptInt) { + s.Aiten = val +} + +// SetTenCard sets the value of TenCard. +func (s *UserList) SetTenCard(val OptString) { + s.TenCard = val +} + +// SetTenDelete sets the value of TenDelete. +func (s *UserList) SetTenDelete(val OptString) { + s.TenDelete = val +} + +// SetTenPost sets the value of TenPost. +func (s *UserList) SetTenPost(val OptString) { + s.TenPost = val +} + +// SetTenGet sets the value of TenGet. +func (s *UserList) SetTenGet(val OptString) { + s.TenGet = val +} + +// SetTenAt sets the value of TenAt. +func (s *UserList) SetTenAt(val OptDateTime) { + s.TenAt = val +} + // SetNext sets the value of Next. func (s *UserList) SetNext(val OptString) { s.Next = val @@ -1655,6 +2645,21 @@ type UserRead struct { Delete OptBool `json:"delete"` CreatedAt OptDateTime `json:"created_at"` UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + 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"` } @@ -1688,6 +2693,81 @@ func (s *UserRead) GetUpdatedAt() OptDateTime { return s.UpdatedAt } +// GetRaidAt returns the value of RaidAt. +func (s *UserRead) GetRaidAt() OptDateTime { + return s.RaidAt +} + +// GetLuck returns the value of Luck. +func (s *UserRead) GetLuck() OptInt { + return s.Luck +} + +// GetLuckAt returns the value of LuckAt. +func (s *UserRead) GetLuckAt() OptDateTime { + return s.LuckAt +} + +// GetLike returns the value of Like. +func (s *UserRead) GetLike() OptInt { + return s.Like +} + +// GetLikeRank returns the value of LikeRank. +func (s *UserRead) GetLikeRank() OptInt { + return s.LikeRank +} + +// GetLikeAt returns the value of LikeAt. +func (s *UserRead) GetLikeAt() OptDateTime { + return s.LikeAt +} + +// GetTen returns the value of Ten. +func (s *UserRead) GetTen() OptBool { + return s.Ten +} + +// GetTenSu returns the value of TenSu. +func (s *UserRead) GetTenSu() OptInt { + return s.TenSu +} + +// GetTenKai returns the value of TenKai. +func (s *UserRead) GetTenKai() OptInt { + return s.TenKai +} + +// GetAiten returns the value of Aiten. +func (s *UserRead) GetAiten() OptInt { + return s.Aiten +} + +// GetTenCard returns the value of TenCard. +func (s *UserRead) GetTenCard() OptString { + return s.TenCard +} + +// GetTenDelete returns the value of TenDelete. +func (s *UserRead) GetTenDelete() OptString { + return s.TenDelete +} + +// GetTenPost returns the value of TenPost. +func (s *UserRead) GetTenPost() OptString { + return s.TenPost +} + +// GetTenGet returns the value of TenGet. +func (s *UserRead) GetTenGet() OptString { + return s.TenGet +} + +// GetTenAt returns the value of TenAt. +func (s *UserRead) GetTenAt() OptDateTime { + return s.TenAt +} + // GetNext returns the value of Next. func (s *UserRead) GetNext() OptString { return s.Next @@ -1723,6 +2803,81 @@ func (s *UserRead) SetUpdatedAt(val OptDateTime) { s.UpdatedAt = val } +// SetRaidAt sets the value of RaidAt. +func (s *UserRead) SetRaidAt(val OptDateTime) { + s.RaidAt = val +} + +// SetLuck sets the value of Luck. +func (s *UserRead) SetLuck(val OptInt) { + s.Luck = val +} + +// SetLuckAt sets the value of LuckAt. +func (s *UserRead) SetLuckAt(val OptDateTime) { + s.LuckAt = val +} + +// SetLike sets the value of Like. +func (s *UserRead) SetLike(val OptInt) { + s.Like = val +} + +// SetLikeRank sets the value of LikeRank. +func (s *UserRead) SetLikeRank(val OptInt) { + s.LikeRank = val +} + +// SetLikeAt sets the value of LikeAt. +func (s *UserRead) SetLikeAt(val OptDateTime) { + s.LikeAt = val +} + +// SetTen sets the value of Ten. +func (s *UserRead) SetTen(val OptBool) { + s.Ten = val +} + +// SetTenSu sets the value of TenSu. +func (s *UserRead) SetTenSu(val OptInt) { + s.TenSu = val +} + +// SetTenKai sets the value of TenKai. +func (s *UserRead) SetTenKai(val OptInt) { + s.TenKai = val +} + +// SetAiten sets the value of Aiten. +func (s *UserRead) SetAiten(val OptInt) { + s.Aiten = val +} + +// SetTenCard sets the value of TenCard. +func (s *UserRead) SetTenCard(val OptString) { + s.TenCard = val +} + +// SetTenDelete sets the value of TenDelete. +func (s *UserRead) SetTenDelete(val OptString) { + s.TenDelete = val +} + +// SetTenPost sets the value of TenPost. +func (s *UserRead) SetTenPost(val OptString) { + s.TenPost = val +} + +// SetTenGet sets the value of TenGet. +func (s *UserRead) SetTenGet(val OptString) { + s.TenGet = val +} + +// SetTenAt sets the value of TenAt. +func (s *UserRead) SetTenAt(val OptDateTime) { + s.TenAt = val +} + // SetNext sets the value of Next. func (s *UserRead) SetNext(val OptString) { s.Next = val @@ -1738,6 +2893,21 @@ type UserUpdate struct { Delete OptBool `json:"delete"` CreatedAt OptDateTime `json:"created_at"` UpdatedAt OptDateTime `json:"updated_at"` + RaidAt OptDateTime `json:"raid_at"` + Luck OptInt `json:"luck"` + LuckAt OptDateTime `json:"luck_at"` + Like OptInt `json:"like"` + LikeRank OptInt `json:"like_rank"` + LikeAt OptDateTime `json:"like_at"` + 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"` } @@ -1771,6 +2941,81 @@ func (s *UserUpdate) GetUpdatedAt() OptDateTime { return s.UpdatedAt } +// GetRaidAt returns the value of RaidAt. +func (s *UserUpdate) GetRaidAt() OptDateTime { + return s.RaidAt +} + +// GetLuck returns the value of Luck. +func (s *UserUpdate) GetLuck() OptInt { + return s.Luck +} + +// GetLuckAt returns the value of LuckAt. +func (s *UserUpdate) GetLuckAt() OptDateTime { + return s.LuckAt +} + +// GetLike returns the value of Like. +func (s *UserUpdate) GetLike() OptInt { + return s.Like +} + +// GetLikeRank returns the value of LikeRank. +func (s *UserUpdate) GetLikeRank() OptInt { + return s.LikeRank +} + +// GetLikeAt returns the value of LikeAt. +func (s *UserUpdate) GetLikeAt() OptDateTime { + return s.LikeAt +} + +// GetTen returns the value of Ten. +func (s *UserUpdate) GetTen() OptBool { + return s.Ten +} + +// GetTenSu returns the value of TenSu. +func (s *UserUpdate) GetTenSu() OptInt { + return s.TenSu +} + +// GetTenKai returns the value of TenKai. +func (s *UserUpdate) GetTenKai() OptInt { + return s.TenKai +} + +// GetAiten returns the value of Aiten. +func (s *UserUpdate) GetAiten() OptInt { + return s.Aiten +} + +// GetTenCard returns the value of TenCard. +func (s *UserUpdate) GetTenCard() OptString { + return s.TenCard +} + +// GetTenDelete returns the value of TenDelete. +func (s *UserUpdate) GetTenDelete() OptString { + return s.TenDelete +} + +// GetTenPost returns the value of TenPost. +func (s *UserUpdate) GetTenPost() OptString { + return s.TenPost +} + +// GetTenGet returns the value of TenGet. +func (s *UserUpdate) GetTenGet() OptString { + return s.TenGet +} + +// GetTenAt returns the value of TenAt. +func (s *UserUpdate) GetTenAt() OptDateTime { + return s.TenAt +} + // GetNext returns the value of Next. func (s *UserUpdate) GetNext() OptString { return s.Next @@ -1806,6 +3051,81 @@ func (s *UserUpdate) SetUpdatedAt(val OptDateTime) { s.UpdatedAt = val } +// SetRaidAt sets the value of RaidAt. +func (s *UserUpdate) SetRaidAt(val OptDateTime) { + s.RaidAt = val +} + +// SetLuck sets the value of Luck. +func (s *UserUpdate) SetLuck(val OptInt) { + s.Luck = val +} + +// SetLuckAt sets the value of LuckAt. +func (s *UserUpdate) SetLuckAt(val OptDateTime) { + s.LuckAt = val +} + +// SetLike sets the value of Like. +func (s *UserUpdate) SetLike(val OptInt) { + s.Like = val +} + +// SetLikeRank sets the value of LikeRank. +func (s *UserUpdate) SetLikeRank(val OptInt) { + s.LikeRank = val +} + +// SetLikeAt sets the value of LikeAt. +func (s *UserUpdate) SetLikeAt(val OptDateTime) { + s.LikeAt = val +} + +// SetTen sets the value of Ten. +func (s *UserUpdate) SetTen(val OptBool) { + s.Ten = val +} + +// SetTenSu sets the value of TenSu. +func (s *UserUpdate) SetTenSu(val OptInt) { + s.TenSu = val +} + +// SetTenKai sets the value of TenKai. +func (s *UserUpdate) SetTenKai(val OptInt) { + s.TenKai = val +} + +// SetAiten sets the value of Aiten. +func (s *UserUpdate) SetAiten(val OptInt) { + s.Aiten = val +} + +// SetTenCard sets the value of TenCard. +func (s *UserUpdate) SetTenCard(val OptString) { + s.TenCard = val +} + +// SetTenDelete sets the value of TenDelete. +func (s *UserUpdate) SetTenDelete(val OptString) { + s.TenDelete = val +} + +// SetTenPost sets the value of TenPost. +func (s *UserUpdate) SetTenPost(val OptString) { + s.TenPost = val +} + +// SetTenGet sets the value of TenGet. +func (s *UserUpdate) SetTenGet(val OptString) { + s.TenGet = val +} + +// SetTenAt sets the value of TenAt. +func (s *UserUpdate) SetTenAt(val OptDateTime) { + s.TenAt = val +} + // SetNext sets the value of Next. func (s *UserUpdate) SetNext(val OptString) { s.Next = val diff --git a/ent/ogent/ogent.go b/ent/ogent/ogent.go index 5b3edf3..779818f 100644 --- a/ent/ogent/ogent.go +++ b/ent/ogent/ogent.go @@ -15,10 +15,10 @@ import ( "os" ) +// origin-config var password = os.Getenv("PASS") var token = os.Getenv("TOKEN") -var zero = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" // OgentHandler implements the ogen generated Handler interface and uses Ent as data layer. type OgentHandler struct { client *ent.Client @@ -42,6 +42,9 @@ func (h *OgentHandler) CreateCard(ctx context.Context, req *CreateCardReq) (Crea if v, ok := req.Card.Get(); ok { b.SetCard(v) } + if v, ok := req.Skill.Get(); ok { + b.SetSkill(v) + } if v, ok := req.Status.Get(); ok { b.SetStatus(v) } @@ -54,11 +57,9 @@ func (h *OgentHandler) CreateCard(ctx context.Context, req *CreateCardReq) (Crea if v, ok := req.CreatedAt.Get(); ok { b.SetCreatedAt(v) } - if v, ok := req.Skill.Get(); ok { - b.SetSkill(v) - } // Add all edges. - + //b.SetOwnerID(req.Owner) + // origin-config if req.Password == password { b.SetOwnerID(req.Owner) } else { @@ -123,12 +124,19 @@ func (h *OgentHandler) ReadCard(ctx context.Context, params ReadCardParams) (Rea // UpdateCard handles PATCH /cards/{id} requests. func (h *OgentHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, params UpdateCardParams) (UpdateCardRes, error) { - b := h.client.Card.UpdateOneID(0) - // Add all fields. - // Add all edges. - if v, ok := req.Owner.Get(); ok { - b.SetOwnerID(v) - } + b := h.client.Card.UpdateOneID(params.ID) + + + // Add all fields. + if v, ok := req.Skill.Get(); ok { + b.SetSkill(v) + } + // Add all edges. + if v, ok := req.Owner.Get(); ok { + b.SetOwnerID(v) + } + + // Persist to storage. e, err := b.Save(ctx) if err != nil { @@ -163,7 +171,6 @@ func (h *OgentHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, param // DeleteCard handles DELETE /cards/{id} requests. func (h *OgentHandler) DeleteCard(ctx context.Context, params DeleteCardParams) (DeleteCardRes, error) { err := h.client.Card.DeleteOneID(0).Exec(ctx) - //err := h.client.Card.DeleteOneID(params.ID).Exec(ctx) if err != nil { switch { case ent.IsNotFound(err): @@ -254,7 +261,7 @@ func (h *OgentHandler) ReadCardOwner(ctx context.Context, params ReadCardOwnerPa func (h *OgentHandler) CreateGroup(ctx context.Context, req *CreateGroupReq) (CreateGroupRes, error) { b := h.client.Group.Create() // Add all fields. - b.SetName(req.Name) + b.SetName("") b.SetPassword(req.Password) // Add all edges. b.AddUserIDs(req.Users...) @@ -359,7 +366,7 @@ func (h *OgentHandler) UpdateGroup(ctx context.Context, req *UpdateGroupReq, par // DeleteGroup handles DELETE /groups/{id} requests. func (h *OgentHandler) DeleteGroup(ctx context.Context, params DeleteGroupParams) (DeleteGroupRes, error) { - err := h.client.Group.DeleteOneID(params.ID).Exec(ctx) + err := h.client.Group.DeleteOneID(0).Exec(ctx) if err != nil { switch { case ent.IsNotFound(err): @@ -459,7 +466,10 @@ func (h *OgentHandler) ListGroupUsers(ctx context.Context, params ListGroupUsers // CreateUser handles POST /users requests. func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (CreateUserRes, error) { b := h.client.User.Create() + // Add all fields. + //b.SetUsername(req.Username) + //origin-config if req.Password == password { b.SetUsername(req.Username) } else { @@ -467,15 +477,67 @@ func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (Crea } b.SetPassword(req.Password) + if v, ok := req.Did.Get(); ok { b.SetDid(v) } + if v, ok := req.Delete.Get(); ok { + b.SetDelete(v) + } + if v, ok := req.Token.Get(); ok { + b.SetToken(v) + } if v, ok := req.CreatedAt.Get(); ok { b.SetCreatedAt(v) } if v, ok := req.UpdatedAt.Get(); ok { b.SetUpdatedAt(v) } + if v, ok := req.RaidAt.Get(); ok { + b.SetRaidAt(v) + } + if v, ok := req.Luck.Get(); ok { + b.SetLuck(v) + } + if v, ok := req.Aiten.Get(); ok { + b.SetAiten(v) + } + if v, ok := req.LuckAt.Get(); ok { + b.SetLuckAt(v) + } + if v, ok := req.Like.Get(); ok { + b.SetLike(v) + } + if v, ok := req.LikeRank.Get(); ok { + b.SetLikeRank(v) + } + if v, ok := req.LikeAt.Get(); ok { + b.SetLikeAt(v) + } + if v, ok := req.Ten.Get(); ok { + b.SetTen(v) + } + if v, ok := req.TenSu.Get(); ok { + b.SetTenSu(v) + } + if v, ok := req.TenKai.Get(); ok { + b.SetTenKai(v) + } + if v, ok := req.TenCard.Get(); ok { + b.SetTenCard(v) + } + if v, ok := req.TenDelete.Get(); ok { + b.SetTenDelete(v) + } + if v, ok := req.TenPost.Get(); ok { + b.SetTenPost(v) + } + if v, ok := req.TenGet.Get(); ok { + b.SetTenGet(v) + } + if v, ok := req.TenAt.Get(); ok { + b.SetTenAt(v) + } if v, ok := req.Next.Get(); ok { b.SetNext(v) } @@ -483,7 +545,6 @@ func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (Crea b.AddCardIDs(req.Card...) // Persist to storage. e, err := b.Save(ctx) - if err != nil { switch { case ent.IsNotSingular(err): @@ -546,16 +607,62 @@ func (h *OgentHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, param if v, ok := req.Token.Get(); ok { if v == token { b.SetToken(v) - // Add all fields. + if v, ok := req.Did.Get(); ok { b.SetDid(v) } if v, ok := req.Delete.Get(); ok { b.SetDelete(v) } + if v, ok := req.UpdatedAt.Get(); ok { b.SetUpdatedAt(v) } + if v, ok := req.RaidAt.Get(); ok { + b.SetRaidAt(v) + } + if v, ok := req.Aiten.Get(); ok { + b.SetAiten(v) + } + if v, ok := req.Luck.Get(); ok { + b.SetLuck(v) + } + if v, ok := req.LuckAt.Get(); ok { + b.SetLuckAt(v) + } + if v, ok := req.Like.Get(); ok { + b.SetLike(v) + } + if v, ok := req.LikeRank.Get(); ok { + b.SetLikeRank(v) + } + if v, ok := req.LikeAt.Get(); ok { + b.SetLikeAt(v) + } + if v, ok := req.Ten.Get(); ok { + b.SetTen(v) + } + if v, ok := req.TenSu.Get(); ok { + b.SetTenSu(v) + } + if v, ok := req.TenKai.Get(); ok { + b.SetTenKai(v) + } + if v, ok := req.TenCard.Get(); ok { + b.SetTenCard(v) + } + if v, ok := req.TenDelete.Get(); ok { + b.SetTenDelete(v) + } + if v, ok := req.TenPost.Get(); ok { + b.SetTenPost(v) + } + if v, ok := req.TenGet.Get(); ok { + b.SetTenGet(v) + } + if v, ok := req.TenAt.Get(); ok { + b.SetTenAt(v) + } if v, ok := req.Next.Get(); ok { b.SetNext(v) } @@ -563,11 +670,11 @@ func (h *OgentHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, param if req.Card != nil { b.ClearCard().AddCardIDs(req.Card...) } - // Persist to storage. } } - e, err := b.Save(ctx) + // Persist to storage. + e, err := b.Save(ctx) if err != nil { switch { case ent.IsNotFound(err): diff --git a/ent/ogent/responses.go b/ent/ogent/responses.go index 12f54ec..5b42e3d 100644 --- a/ent/ogent/responses.go +++ b/ent/ogent/responses.go @@ -147,6 +147,21 @@ func NewCardOwnerRead(e *ent.User) *CardOwnerRead { ret.Delete = NewOptBool(e.Delete) ret.CreatedAt = NewOptDateTime(e.CreatedAt) ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.RaidAt = NewOptDateTime(e.RaidAt) + ret.Luck = NewOptInt(e.Luck) + ret.LuckAt = NewOptDateTime(e.LuckAt) + ret.Like = NewOptInt(e.Like) + ret.LikeRank = NewOptInt(e.LikeRank) + ret.LikeAt = NewOptDateTime(e.LikeAt) + ret.Ten = NewOptBool(e.Ten) + ret.TenSu = NewOptInt(e.TenSu) + ret.TenKai = NewOptInt(e.TenKai) + ret.Aiten = NewOptInt(e.Aiten) + ret.TenCard = NewOptString(e.TenCard) + ret.TenDelete = NewOptString(e.TenDelete) + ret.TenPost = NewOptString(e.TenPost) + ret.TenGet = NewOptString(e.TenGet) + ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) return &ret } @@ -292,6 +307,21 @@ func NewGroupUsersList(e *ent.User) *GroupUsersList { ret.Delete = NewOptBool(e.Delete) ret.CreatedAt = NewOptDateTime(e.CreatedAt) ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.RaidAt = NewOptDateTime(e.RaidAt) + ret.Luck = NewOptInt(e.Luck) + ret.LuckAt = NewOptDateTime(e.LuckAt) + ret.Like = NewOptInt(e.Like) + ret.LikeRank = NewOptInt(e.LikeRank) + ret.LikeAt = NewOptDateTime(e.LikeAt) + ret.Ten = NewOptBool(e.Ten) + ret.TenSu = NewOptInt(e.TenSu) + ret.TenKai = NewOptInt(e.TenKai) + ret.Aiten = NewOptInt(e.Aiten) + ret.TenCard = NewOptString(e.TenCard) + ret.TenDelete = NewOptString(e.TenDelete) + ret.TenPost = NewOptString(e.TenPost) + ret.TenGet = NewOptString(e.TenGet) + ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) return &ret } @@ -325,6 +355,21 @@ func NewUserCreate(e *ent.User) *UserCreate { ret.Delete = NewOptBool(e.Delete) ret.CreatedAt = NewOptDateTime(e.CreatedAt) ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.RaidAt = NewOptDateTime(e.RaidAt) + ret.Luck = NewOptInt(e.Luck) + ret.LuckAt = NewOptDateTime(e.LuckAt) + ret.Like = NewOptInt(e.Like) + ret.LikeRank = NewOptInt(e.LikeRank) + ret.LikeAt = NewOptDateTime(e.LikeAt) + ret.Ten = NewOptBool(e.Ten) + ret.TenSu = NewOptInt(e.TenSu) + ret.TenKai = NewOptInt(e.TenKai) + ret.Aiten = NewOptInt(e.Aiten) + ret.TenCard = NewOptString(e.TenCard) + ret.TenDelete = NewOptString(e.TenDelete) + ret.TenPost = NewOptString(e.TenPost) + ret.TenGet = NewOptString(e.TenGet) + ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) return &ret } @@ -358,6 +403,21 @@ func NewUserList(e *ent.User) *UserList { ret.Delete = NewOptBool(e.Delete) ret.CreatedAt = NewOptDateTime(e.CreatedAt) ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.RaidAt = NewOptDateTime(e.RaidAt) + ret.Luck = NewOptInt(e.Luck) + ret.LuckAt = NewOptDateTime(e.LuckAt) + ret.Like = NewOptInt(e.Like) + ret.LikeRank = NewOptInt(e.LikeRank) + ret.LikeAt = NewOptDateTime(e.LikeAt) + ret.Ten = NewOptBool(e.Ten) + ret.TenSu = NewOptInt(e.TenSu) + ret.TenKai = NewOptInt(e.TenKai) + ret.Aiten = NewOptInt(e.Aiten) + ret.TenCard = NewOptString(e.TenCard) + ret.TenDelete = NewOptString(e.TenDelete) + ret.TenPost = NewOptString(e.TenPost) + ret.TenGet = NewOptString(e.TenGet) + ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) return &ret } @@ -391,6 +451,21 @@ func NewUserRead(e *ent.User) *UserRead { ret.Delete = NewOptBool(e.Delete) ret.CreatedAt = NewOptDateTime(e.CreatedAt) ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.RaidAt = NewOptDateTime(e.RaidAt) + ret.Luck = NewOptInt(e.Luck) + ret.LuckAt = NewOptDateTime(e.LuckAt) + ret.Like = NewOptInt(e.Like) + ret.LikeRank = NewOptInt(e.LikeRank) + ret.LikeAt = NewOptDateTime(e.LikeAt) + ret.Ten = NewOptBool(e.Ten) + ret.TenSu = NewOptInt(e.TenSu) + ret.TenKai = NewOptInt(e.TenKai) + ret.Aiten = NewOptInt(e.Aiten) + ret.TenCard = NewOptString(e.TenCard) + ret.TenDelete = NewOptString(e.TenDelete) + ret.TenPost = NewOptString(e.TenPost) + ret.TenGet = NewOptString(e.TenGet) + ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) return &ret } @@ -424,6 +499,21 @@ func NewUserUpdate(e *ent.User) *UserUpdate { ret.Delete = NewOptBool(e.Delete) ret.CreatedAt = NewOptDateTime(e.CreatedAt) ret.UpdatedAt = NewOptDateTime(e.UpdatedAt) + ret.RaidAt = NewOptDateTime(e.RaidAt) + ret.Luck = NewOptInt(e.Luck) + ret.LuckAt = NewOptDateTime(e.LuckAt) + ret.Like = NewOptInt(e.Like) + ret.LikeRank = NewOptInt(e.LikeRank) + ret.LikeAt = NewOptDateTime(e.LikeAt) + ret.Ten = NewOptBool(e.Ten) + ret.TenSu = NewOptInt(e.TenSu) + ret.TenKai = NewOptInt(e.TenKai) + ret.Aiten = NewOptInt(e.Aiten) + ret.TenCard = NewOptString(e.TenCard) + ret.TenDelete = NewOptString(e.TenDelete) + ret.TenPost = NewOptString(e.TenPost) + ret.TenGet = NewOptString(e.TenGet) + ret.TenAt = NewOptDateTime(e.TenAt) ret.Next = NewOptString(e.Next) return &ret } diff --git a/ent/openapi.json b/ent/openapi.json index 9ca4f54..d3f773f 100644 --- a/ent/openapi.json +++ b/ent/openapi.json @@ -30,7 +30,7 @@ "description": "item count to render per page", "schema": { "type": "integer", - "maximum": 3500, + "maximum": 4000, "minimum": 1 } } @@ -372,7 +372,7 @@ "description": "item count to render per page", "schema": { "type": "integer", - "maximum": 3500, + "maximum": 4000, "minimum": 1 } } @@ -698,7 +698,7 @@ "description": "item count to render per page", "schema": { "type": "integer", - "maximum": 3500, + "maximum": 4000, "minimum": 1 } } @@ -768,6 +768,55 @@ "type": "string", "format": "date-time" }, + "raid_at": { + "type": "string", + "format": "date-time" + }, + "luck": { + "type": "integer" + }, + "luck_at": { + "type": "string", + "format": "date-time" + }, + "like": { + "type": "integer" + }, + "like_rank": { + "type": "integer" + }, + "like_at": { + "type": "string", + "format": "date-time" + }, + "ten": { + "type": "boolean" + }, + "ten_su": { + "type": "integer" + }, + "ten_kai": { + "type": "integer" + }, + "aiten": { + "type": "integer" + }, + "ten_card": { + "type": "string" + }, + "ten_delete": { + "type": "string" + }, + "ten_post": { + "type": "string" + }, + "ten_get": { + "type": "string" + }, + "ten_at": { + "type": "string", + "format": "date-time" + }, "next": { "type": "string" }, @@ -928,6 +977,55 @@ "type": "string", "format": "date-time" }, + "raid_at": { + "type": "string", + "format": "date-time" + }, + "luck": { + "type": "integer" + }, + "luck_at": { + "type": "string", + "format": "date-time" + }, + "like": { + "type": "integer" + }, + "like_rank": { + "type": "integer" + }, + "like_at": { + "type": "string", + "format": "date-time" + }, + "ten": { + "type": "boolean" + }, + "ten_su": { + "type": "integer" + }, + "ten_kai": { + "type": "integer" + }, + "aiten": { + "type": "integer" + }, + "ten_card": { + "type": "string" + }, + "ten_delete": { + "type": "string" + }, + "ten_post": { + "type": "string" + }, + "ten_get": { + "type": "string" + }, + "ten_at": { + "type": "string", + "format": "date-time" + }, "next": { "type": "string" }, @@ -1242,6 +1340,55 @@ "type": "string", "format": "date-time" }, + "raid_at": { + "type": "string", + "format": "date-time" + }, + "luck": { + "type": "integer" + }, + "luck_at": { + "type": "string", + "format": "date-time" + }, + "like": { + "type": "integer" + }, + "like_rank": { + "type": "integer" + }, + "like_at": { + "type": "string", + "format": "date-time" + }, + "ten": { + "type": "boolean" + }, + "ten_su": { + "type": "integer" + }, + "ten_kai": { + "type": "integer" + }, + "aiten": { + "type": "integer" + }, + "ten_card": { + "type": "string" + }, + "ten_delete": { + "type": "string" + }, + "ten_post": { + "type": "string" + }, + "ten_get": { + "type": "string" + }, + "ten_at": { + "type": "string", + "format": "date-time" + }, "next": { "type": "string" } @@ -1359,6 +1506,55 @@ "type": "string", "format": "date-time" }, + "raid_at": { + "type": "string", + "format": "date-time" + }, + "luck": { + "type": "integer" + }, + "luck_at": { + "type": "string", + "format": "date-time" + }, + "like": { + "type": "integer" + }, + "like_rank": { + "type": "integer" + }, + "like_at": { + "type": "string", + "format": "date-time" + }, + "ten": { + "type": "boolean" + }, + "ten_su": { + "type": "integer" + }, + "ten_kai": { + "type": "integer" + }, + "aiten": { + "type": "integer" + }, + "ten_card": { + "type": "string" + }, + "ten_delete": { + "type": "string" + }, + "ten_post": { + "type": "string" + }, + "ten_get": { + "type": "string" + }, + "ten_at": { + "type": "string", + "format": "date-time" + }, "next": { "type": "string" } @@ -1397,6 +1593,55 @@ "type": "string", "format": "date-time" }, + "raid_at": { + "type": "string", + "format": "date-time" + }, + "luck": { + "type": "integer" + }, + "luck_at": { + "type": "string", + "format": "date-time" + }, + "like": { + "type": "integer" + }, + "like_rank": { + "type": "integer" + }, + "like_at": { + "type": "string", + "format": "date-time" + }, + "ten": { + "type": "boolean" + }, + "ten_su": { + "type": "integer" + }, + "ten_kai": { + "type": "integer" + }, + "aiten": { + "type": "integer" + }, + "ten_card": { + "type": "string" + }, + "ten_delete": { + "type": "string" + }, + "ten_post": { + "type": "string" + }, + "ten_get": { + "type": "string" + }, + "ten_at": { + "type": "string", + "format": "date-time" + }, "next": { "type": "string" }, @@ -1436,6 +1681,55 @@ "type": "string", "format": "date-time" }, + "raid_at": { + "type": "string", + "format": "date-time" + }, + "luck": { + "type": "integer" + }, + "luck_at": { + "type": "string", + "format": "date-time" + }, + "like": { + "type": "integer" + }, + "like_rank": { + "type": "integer" + }, + "like_at": { + "type": "string", + "format": "date-time" + }, + "ten": { + "type": "boolean" + }, + "ten_su": { + "type": "integer" + }, + "ten_kai": { + "type": "integer" + }, + "aiten": { + "type": "integer" + }, + "ten_card": { + "type": "string" + }, + "ten_delete": { + "type": "string" + }, + "ten_post": { + "type": "string" + }, + "ten_get": { + "type": "string" + }, + "ten_at": { + "type": "string", + "format": "date-time" + }, "next": { "type": "string" } @@ -1468,6 +1762,55 @@ "type": "string", "format": "date-time" }, + "raid_at": { + "type": "string", + "format": "date-time" + }, + "luck": { + "type": "integer" + }, + "luck_at": { + "type": "string", + "format": "date-time" + }, + "like": { + "type": "integer" + }, + "like_rank": { + "type": "integer" + }, + "like_at": { + "type": "string", + "format": "date-time" + }, + "ten": { + "type": "boolean" + }, + "ten_su": { + "type": "integer" + }, + "ten_kai": { + "type": "integer" + }, + "aiten": { + "type": "integer" + }, + "ten_card": { + "type": "string" + }, + "ten_delete": { + "type": "string" + }, + "ten_post": { + "type": "string" + }, + "ten_get": { + "type": "string" + }, + "ten_at": { + "type": "string", + "format": "date-time" + }, "next": { "type": "string" } @@ -1500,6 +1843,55 @@ "type": "string", "format": "date-time" }, + "raid_at": { + "type": "string", + "format": "date-time" + }, + "luck": { + "type": "integer" + }, + "luck_at": { + "type": "string", + "format": "date-time" + }, + "like": { + "type": "integer" + }, + "like_rank": { + "type": "integer" + }, + "like_at": { + "type": "string", + "format": "date-time" + }, + "ten": { + "type": "boolean" + }, + "ten_su": { + "type": "integer" + }, + "ten_kai": { + "type": "integer" + }, + "aiten": { + "type": "integer" + }, + "ten_card": { + "type": "string" + }, + "ten_delete": { + "type": "string" + }, + "ten_post": { + "type": "string" + }, + "ten_get": { + "type": "string" + }, + "ten_at": { + "type": "string", + "format": "date-time" + }, "next": { "type": "string" } @@ -1532,6 +1924,55 @@ "type": "string", "format": "date-time" }, + "raid_at": { + "type": "string", + "format": "date-time" + }, + "luck": { + "type": "integer" + }, + "luck_at": { + "type": "string", + "format": "date-time" + }, + "like": { + "type": "integer" + }, + "like_rank": { + "type": "integer" + }, + "like_at": { + "type": "string", + "format": "date-time" + }, + "ten": { + "type": "boolean" + }, + "ten_su": { + "type": "integer" + }, + "ten_kai": { + "type": "integer" + }, + "aiten": { + "type": "integer" + }, + "ten_card": { + "type": "string" + }, + "ten_delete": { + "type": "string" + }, + "ten_post": { + "type": "string" + }, + "ten_get": { + "type": "string" + }, + "ten_at": { + "type": "string", + "format": "date-time" + }, "next": { "type": "string" } diff --git a/ent/runtime.go b/ent/runtime.go index 7dd9eeb..e73f90c 100644 --- a/ent/runtime.go +++ b/ent/runtime.go @@ -86,8 +86,24 @@ func init() { userDescUpdatedAt := userFields[6].Descriptor() // user.DefaultUpdatedAt holds the default value on creation for the updated_at field. user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() time.Time) + // userDescRaidAt is the schema descriptor for raid_at field. + userDescRaidAt := userFields[7].Descriptor() + // user.DefaultRaidAt holds the default value on creation for the raid_at field. + user.DefaultRaidAt = userDescRaidAt.Default.(func() time.Time) + // userDescLuckAt is the schema descriptor for luck_at field. + userDescLuckAt := userFields[9].Descriptor() + // user.DefaultLuckAt holds the default value on creation for the luck_at field. + user.DefaultLuckAt = userDescLuckAt.Default.(func() time.Time) + // userDescLikeAt is the schema descriptor for like_at field. + userDescLikeAt := userFields[12].Descriptor() + // user.DefaultLikeAt holds the default value on creation for the like_at field. + user.DefaultLikeAt = userDescLikeAt.Default.(func() time.Time) + // userDescTenAt is the schema descriptor for ten_at field. + userDescTenAt := userFields[21].Descriptor() + // user.DefaultTenAt holds the default value on creation for the ten_at field. + user.DefaultTenAt = userDescTenAt.Default.(func() time.Time) // userDescNext is the schema descriptor for next field. - userDescNext := userFields[7].Descriptor() + userDescNext := userFields[22].Descriptor() // user.DefaultNext holds the default value on creation for the next field. user.DefaultNext = userDescNext.Default.(string) } diff --git a/ent/schema/card.go b/ent/schema/card.go index b62809b..7b1d3cd 100644 --- a/ent/schema/card.go +++ b/ent/schema/card.go @@ -119,6 +119,10 @@ func (Card) Fields() []ent.Field { cp = 800 + cp + rand.Intn(1500) } + if card == 25 { + cp = 0 + } + return cp }). Optional(), diff --git a/ent/schema/user.go b/ent/schema/user.go index 6b5dc4c..6083393 100644 --- a/ent/schema/user.go +++ b/ent/schema/user.go @@ -64,6 +64,63 @@ func (User) Fields() []ent.Field { return time.Now().In(jst) }), + field.Time("raid_at"). + Optional(). + Default(func() time.Time { + return time.Now().In(jst) + }), + + field.Int("luck"). + Optional(), + + field.Time("luck_at"). + Optional(). + Default(func() time.Time { + return time.Now().In(jst) + }), + + field.Int("like"). + Optional(), + + field.Int("like_rank"). + Optional(), + + field.Time("like_at"). + Optional(). + Default(func() time.Time { + return time.Now().In(jst) + }), + + field.Bool("ten"). + Optional(), + + field.Int("ten_su"). + Optional(), + + field.Int("ten_kai"). + Optional(), + + field.Int("aiten"). + Optional(), + + field.String("ten_card"). + Optional(), + + field.String("ten_delete"). + Optional(), + + field.String("ten_post"). + Optional(), + + field.String("ten_get"). + Optional(), + + field.Time("ten_at"). + Optional(). + Default(func() time.Time { + return time.Now().In(jst) + }), + field.String("next"). Default(Nextime()). Optional(), diff --git a/ent/user.go b/ent/user.go index 44c1b88..8d23fb1 100644 --- a/ent/user.go +++ b/ent/user.go @@ -30,6 +30,36 @@ type User struct { CreatedAt time.Time `json:"created_at,omitempty"` // UpdatedAt holds the value of the "updated_at" field. UpdatedAt time.Time `json:"updated_at,omitempty"` + // RaidAt holds the value of the "raid_at" field. + RaidAt time.Time `json:"raid_at,omitempty"` + // Luck holds the value of the "luck" field. + Luck int `json:"luck,omitempty"` + // LuckAt holds the value of the "luck_at" field. + LuckAt time.Time `json:"luck_at,omitempty"` + // Like holds the value of the "like" field. + Like int `json:"like,omitempty"` + // LikeRank holds the value of the "like_rank" field. + LikeRank int `json:"like_rank,omitempty"` + // LikeAt holds the value of the "like_at" field. + LikeAt time.Time `json:"like_at,omitempty"` + // Ten holds the value of the "ten" field. + Ten bool `json:"ten,omitempty"` + // TenSu holds the value of the "ten_su" field. + TenSu int `json:"ten_su,omitempty"` + // TenKai holds the value of the "ten_kai" field. + TenKai int `json:"ten_kai,omitempty"` + // Aiten holds the value of the "aiten" field. + Aiten int `json:"aiten,omitempty"` + // TenCard holds the value of the "ten_card" field. + TenCard string `json:"ten_card,omitempty"` + // TenDelete holds the value of the "ten_delete" field. + TenDelete string `json:"ten_delete,omitempty"` + // TenPost holds the value of the "ten_post" field. + TenPost string `json:"ten_post,omitempty"` + // TenGet holds the value of the "ten_get" field. + TenGet string `json:"ten_get,omitempty"` + // TenAt holds the value of the "ten_at" field. + TenAt time.Time `json:"ten_at,omitempty"` // Next holds the value of the "next" field. Next string `json:"next,omitempty"` // Edges holds the relations/edges for other nodes in the graph. @@ -61,13 +91,13 @@ func (*User) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) for i := range columns { switch columns[i] { - case user.FieldDelete: + case user.FieldDelete, user.FieldTen: values[i] = new(sql.NullBool) - case user.FieldID: + case user.FieldID, user.FieldLuck, user.FieldLike, user.FieldLikeRank, user.FieldTenSu, user.FieldTenKai, user.FieldAiten: values[i] = new(sql.NullInt64) - case user.FieldUsername, user.FieldDid, user.FieldToken, user.FieldPassword, user.FieldNext: + 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: + case user.FieldCreatedAt, user.FieldUpdatedAt, user.FieldRaidAt, user.FieldLuckAt, user.FieldLikeAt, user.FieldTenAt: values[i] = new(sql.NullTime) case user.ForeignKeys[0]: // group_users values[i] = new(sql.NullInt64) @@ -134,6 +164,96 @@ func (u *User) assignValues(columns []string, values []any) error { } else if value.Valid { u.UpdatedAt = value.Time } + case user.FieldRaidAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field raid_at", values[i]) + } else if value.Valid { + u.RaidAt = value.Time + } + case user.FieldLuck: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field luck", values[i]) + } else if value.Valid { + u.Luck = int(value.Int64) + } + case user.FieldLuckAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field luck_at", values[i]) + } else if value.Valid { + u.LuckAt = value.Time + } + case user.FieldLike: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field like", values[i]) + } else if value.Valid { + u.Like = int(value.Int64) + } + case user.FieldLikeRank: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field like_rank", values[i]) + } else if value.Valid { + u.LikeRank = int(value.Int64) + } + case user.FieldLikeAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field like_at", values[i]) + } else if value.Valid { + u.LikeAt = value.Time + } + case user.FieldTen: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field ten", values[i]) + } else if value.Valid { + u.Ten = value.Bool + } + case user.FieldTenSu: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field ten_su", values[i]) + } else if value.Valid { + u.TenSu = int(value.Int64) + } + case user.FieldTenKai: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field ten_kai", values[i]) + } else if value.Valid { + u.TenKai = int(value.Int64) + } + case user.FieldAiten: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field aiten", values[i]) + } else if value.Valid { + u.Aiten = int(value.Int64) + } + case user.FieldTenCard: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field ten_card", values[i]) + } else if value.Valid { + u.TenCard = value.String + } + case user.FieldTenDelete: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field ten_delete", values[i]) + } else if value.Valid { + u.TenDelete = value.String + } + case user.FieldTenPost: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field ten_post", values[i]) + } else if value.Valid { + u.TenPost = value.String + } + case user.FieldTenGet: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field ten_get", values[i]) + } else if value.Valid { + u.TenGet = value.String + } + case user.FieldTenAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field ten_at", values[i]) + } else if value.Valid { + u.TenAt = value.Time + } case user.FieldNext: if value, ok := values[i].(*sql.NullString); !ok { return fmt.Errorf("unexpected type %T for field next", values[i]) @@ -199,6 +319,51 @@ func (u *User) String() string { builder.WriteString("updated_at=") builder.WriteString(u.UpdatedAt.Format(time.ANSIC)) builder.WriteString(", ") + builder.WriteString("raid_at=") + builder.WriteString(u.RaidAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("luck=") + builder.WriteString(fmt.Sprintf("%v", u.Luck)) + builder.WriteString(", ") + builder.WriteString("luck_at=") + builder.WriteString(u.LuckAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("like=") + builder.WriteString(fmt.Sprintf("%v", u.Like)) + builder.WriteString(", ") + builder.WriteString("like_rank=") + builder.WriteString(fmt.Sprintf("%v", u.LikeRank)) + builder.WriteString(", ") + builder.WriteString("like_at=") + builder.WriteString(u.LikeAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("ten=") + builder.WriteString(fmt.Sprintf("%v", u.Ten)) + builder.WriteString(", ") + builder.WriteString("ten_su=") + builder.WriteString(fmt.Sprintf("%v", u.TenSu)) + builder.WriteString(", ") + builder.WriteString("ten_kai=") + builder.WriteString(fmt.Sprintf("%v", u.TenKai)) + builder.WriteString(", ") + builder.WriteString("aiten=") + builder.WriteString(fmt.Sprintf("%v", u.Aiten)) + builder.WriteString(", ") + builder.WriteString("ten_card=") + builder.WriteString(u.TenCard) + builder.WriteString(", ") + builder.WriteString("ten_delete=") + builder.WriteString(u.TenDelete) + builder.WriteString(", ") + builder.WriteString("ten_post=") + builder.WriteString(u.TenPost) + builder.WriteString(", ") + builder.WriteString("ten_get=") + builder.WriteString(u.TenGet) + builder.WriteString(", ") + builder.WriteString("ten_at=") + builder.WriteString(u.TenAt.Format(time.ANSIC)) + builder.WriteString(", ") builder.WriteString("next=") builder.WriteString(u.Next) builder.WriteByte(')') diff --git a/ent/user/user.go b/ent/user/user.go index aef9fe8..349a080 100644 --- a/ent/user/user.go +++ b/ent/user/user.go @@ -25,6 +25,36 @@ const ( FieldCreatedAt = "created_at" // FieldUpdatedAt holds the string denoting the updated_at field in the database. FieldUpdatedAt = "updated_at" + // FieldRaidAt holds the string denoting the raid_at field in the database. + FieldRaidAt = "raid_at" + // FieldLuck holds the string denoting the luck field in the database. + FieldLuck = "luck" + // FieldLuckAt holds the string denoting the luck_at field in the database. + FieldLuckAt = "luck_at" + // FieldLike holds the string denoting the like field in the database. + FieldLike = "like" + // FieldLikeRank holds the string denoting the like_rank field in the database. + FieldLikeRank = "like_rank" + // FieldLikeAt holds the string denoting the like_at field in the database. + FieldLikeAt = "like_at" + // FieldTen holds the string denoting the ten field in the database. + FieldTen = "ten" + // FieldTenSu holds the string denoting the ten_su field in the database. + FieldTenSu = "ten_su" + // FieldTenKai holds the string denoting the ten_kai field in the database. + FieldTenKai = "ten_kai" + // FieldAiten holds the string denoting the aiten field in the database. + FieldAiten = "aiten" + // FieldTenCard holds the string denoting the ten_card field in the database. + FieldTenCard = "ten_card" + // FieldTenDelete holds the string denoting the ten_delete field in the database. + FieldTenDelete = "ten_delete" + // FieldTenPost holds the string denoting the ten_post field in the database. + FieldTenPost = "ten_post" + // FieldTenGet holds the string denoting the ten_get field in the database. + FieldTenGet = "ten_get" + // FieldTenAt holds the string denoting the ten_at field in the database. + FieldTenAt = "ten_at" // FieldNext holds the string denoting the next field in the database. FieldNext = "next" // EdgeCard holds the string denoting the card edge name in mutations. @@ -50,6 +80,21 @@ var Columns = []string{ FieldPassword, FieldCreatedAt, FieldUpdatedAt, + FieldRaidAt, + FieldLuck, + FieldLuckAt, + FieldLike, + FieldLikeRank, + FieldLikeAt, + FieldTen, + FieldTenSu, + FieldTenKai, + FieldAiten, + FieldTenCard, + FieldTenDelete, + FieldTenPost, + FieldTenGet, + FieldTenAt, FieldNext, } @@ -85,6 +130,14 @@ var ( DefaultCreatedAt func() time.Time // DefaultUpdatedAt holds the default value on creation for the "updated_at" field. DefaultUpdatedAt func() time.Time + // DefaultRaidAt holds the default value on creation for the "raid_at" field. + DefaultRaidAt func() time.Time + // DefaultLuckAt holds the default value on creation for the "luck_at" field. + DefaultLuckAt func() time.Time + // DefaultLikeAt holds the default value on creation for the "like_at" field. + DefaultLikeAt func() time.Time + // DefaultTenAt holds the default value on creation for the "ten_at" field. + DefaultTenAt func() time.Time // DefaultNext holds the default value on creation for the "next" field. DefaultNext string ) diff --git a/ent/user/where.go b/ent/user/where.go index f4525f4..5895a44 100644 --- a/ent/user/where.go +++ b/ent/user/where.go @@ -90,6 +90,81 @@ func UpdatedAt(v time.Time) predicate.User { return predicate.User(sql.FieldEQ(FieldUpdatedAt, v)) } +// RaidAt applies equality check predicate on the "raid_at" field. It's identical to RaidAtEQ. +func RaidAt(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldRaidAt, v)) +} + +// Luck applies equality check predicate on the "luck" field. It's identical to LuckEQ. +func Luck(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldLuck, v)) +} + +// LuckAt applies equality check predicate on the "luck_at" field. It's identical to LuckAtEQ. +func LuckAt(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldLuckAt, v)) +} + +// Like applies equality check predicate on the "like" field. It's identical to LikeEQ. +func Like(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldLike, v)) +} + +// LikeRank applies equality check predicate on the "like_rank" field. It's identical to LikeRankEQ. +func LikeRank(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldLikeRank, v)) +} + +// LikeAt applies equality check predicate on the "like_at" field. It's identical to LikeAtEQ. +func LikeAt(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldLikeAt, v)) +} + +// Ten applies equality check predicate on the "ten" field. It's identical to TenEQ. +func Ten(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldTen, v)) +} + +// TenSu applies equality check predicate on the "ten_su" field. It's identical to TenSuEQ. +func TenSu(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenSu, v)) +} + +// TenKai applies equality check predicate on the "ten_kai" field. It's identical to TenKaiEQ. +func TenKai(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenKai, v)) +} + +// Aiten applies equality check predicate on the "aiten" field. It's identical to AitenEQ. +func Aiten(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldAiten, v)) +} + +// TenCard applies equality check predicate on the "ten_card" field. It's identical to TenCardEQ. +func TenCard(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenCard, v)) +} + +// TenDelete applies equality check predicate on the "ten_delete" field. It's identical to TenDeleteEQ. +func TenDelete(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenDelete, v)) +} + +// TenPost applies equality check predicate on the "ten_post" field. It's identical to TenPostEQ. +func TenPost(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenPost, v)) +} + +// TenGet applies equality check predicate on the "ten_get" field. It's identical to TenGetEQ. +func TenGet(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenGet, v)) +} + +// TenAt applies equality check predicate on the "ten_at" field. It's identical to TenAtEQ. +func TenAt(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenAt, v)) +} + // Next applies equality check predicate on the "next" field. It's identical to NextEQ. func Next(v string) predicate.User { return predicate.User(sql.FieldEQ(FieldNext, v)) @@ -495,6 +570,826 @@ func UpdatedAtNotNil() predicate.User { return predicate.User(sql.FieldNotNull(FieldUpdatedAt)) } +// RaidAtEQ applies the EQ predicate on the "raid_at" field. +func RaidAtEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldRaidAt, v)) +} + +// RaidAtNEQ applies the NEQ predicate on the "raid_at" field. +func RaidAtNEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldNEQ(FieldRaidAt, v)) +} + +// RaidAtIn applies the In predicate on the "raid_at" field. +func RaidAtIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldIn(FieldRaidAt, vs...)) +} + +// RaidAtNotIn applies the NotIn predicate on the "raid_at" field. +func RaidAtNotIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldNotIn(FieldRaidAt, vs...)) +} + +// RaidAtGT applies the GT predicate on the "raid_at" field. +func RaidAtGT(v time.Time) predicate.User { + return predicate.User(sql.FieldGT(FieldRaidAt, v)) +} + +// RaidAtGTE applies the GTE predicate on the "raid_at" field. +func RaidAtGTE(v time.Time) predicate.User { + return predicate.User(sql.FieldGTE(FieldRaidAt, v)) +} + +// RaidAtLT applies the LT predicate on the "raid_at" field. +func RaidAtLT(v time.Time) predicate.User { + return predicate.User(sql.FieldLT(FieldRaidAt, v)) +} + +// RaidAtLTE applies the LTE predicate on the "raid_at" field. +func RaidAtLTE(v time.Time) predicate.User { + return predicate.User(sql.FieldLTE(FieldRaidAt, v)) +} + +// RaidAtIsNil applies the IsNil predicate on the "raid_at" field. +func RaidAtIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldRaidAt)) +} + +// RaidAtNotNil applies the NotNil predicate on the "raid_at" field. +func RaidAtNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldRaidAt)) +} + +// LuckEQ applies the EQ predicate on the "luck" field. +func LuckEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldLuck, v)) +} + +// LuckNEQ applies the NEQ predicate on the "luck" field. +func LuckNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldLuck, v)) +} + +// LuckIn applies the In predicate on the "luck" field. +func LuckIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldLuck, vs...)) +} + +// LuckNotIn applies the NotIn predicate on the "luck" field. +func LuckNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldLuck, vs...)) +} + +// LuckGT applies the GT predicate on the "luck" field. +func LuckGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldLuck, v)) +} + +// LuckGTE applies the GTE predicate on the "luck" field. +func LuckGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldLuck, v)) +} + +// LuckLT applies the LT predicate on the "luck" field. +func LuckLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldLuck, v)) +} + +// LuckLTE applies the LTE predicate on the "luck" field. +func LuckLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldLuck, v)) +} + +// LuckIsNil applies the IsNil predicate on the "luck" field. +func LuckIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldLuck)) +} + +// LuckNotNil applies the NotNil predicate on the "luck" field. +func LuckNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldLuck)) +} + +// LuckAtEQ applies the EQ predicate on the "luck_at" field. +func LuckAtEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldLuckAt, v)) +} + +// LuckAtNEQ applies the NEQ predicate on the "luck_at" field. +func LuckAtNEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldNEQ(FieldLuckAt, v)) +} + +// LuckAtIn applies the In predicate on the "luck_at" field. +func LuckAtIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldIn(FieldLuckAt, vs...)) +} + +// LuckAtNotIn applies the NotIn predicate on the "luck_at" field. +func LuckAtNotIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldNotIn(FieldLuckAt, vs...)) +} + +// LuckAtGT applies the GT predicate on the "luck_at" field. +func LuckAtGT(v time.Time) predicate.User { + return predicate.User(sql.FieldGT(FieldLuckAt, v)) +} + +// LuckAtGTE applies the GTE predicate on the "luck_at" field. +func LuckAtGTE(v time.Time) predicate.User { + return predicate.User(sql.FieldGTE(FieldLuckAt, v)) +} + +// LuckAtLT applies the LT predicate on the "luck_at" field. +func LuckAtLT(v time.Time) predicate.User { + return predicate.User(sql.FieldLT(FieldLuckAt, v)) +} + +// LuckAtLTE applies the LTE predicate on the "luck_at" field. +func LuckAtLTE(v time.Time) predicate.User { + return predicate.User(sql.FieldLTE(FieldLuckAt, v)) +} + +// LuckAtIsNil applies the IsNil predicate on the "luck_at" field. +func LuckAtIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldLuckAt)) +} + +// LuckAtNotNil applies the NotNil predicate on the "luck_at" field. +func LuckAtNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldLuckAt)) +} + +// LikeEQ applies the EQ predicate on the "like" field. +func LikeEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldLike, v)) +} + +// LikeNEQ applies the NEQ predicate on the "like" field. +func LikeNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldLike, v)) +} + +// LikeIn applies the In predicate on the "like" field. +func LikeIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldLike, vs...)) +} + +// LikeNotIn applies the NotIn predicate on the "like" field. +func LikeNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldLike, vs...)) +} + +// LikeGT applies the GT predicate on the "like" field. +func LikeGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldLike, v)) +} + +// LikeGTE applies the GTE predicate on the "like" field. +func LikeGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldLike, v)) +} + +// LikeLT applies the LT predicate on the "like" field. +func LikeLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldLike, v)) +} + +// LikeLTE applies the LTE predicate on the "like" field. +func LikeLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldLike, v)) +} + +// LikeIsNil applies the IsNil predicate on the "like" field. +func LikeIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldLike)) +} + +// LikeNotNil applies the NotNil predicate on the "like" field. +func LikeNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldLike)) +} + +// LikeRankEQ applies the EQ predicate on the "like_rank" field. +func LikeRankEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldLikeRank, v)) +} + +// LikeRankNEQ applies the NEQ predicate on the "like_rank" field. +func LikeRankNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldLikeRank, v)) +} + +// LikeRankIn applies the In predicate on the "like_rank" field. +func LikeRankIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldLikeRank, vs...)) +} + +// LikeRankNotIn applies the NotIn predicate on the "like_rank" field. +func LikeRankNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldLikeRank, vs...)) +} + +// LikeRankGT applies the GT predicate on the "like_rank" field. +func LikeRankGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldLikeRank, v)) +} + +// LikeRankGTE applies the GTE predicate on the "like_rank" field. +func LikeRankGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldLikeRank, v)) +} + +// LikeRankLT applies the LT predicate on the "like_rank" field. +func LikeRankLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldLikeRank, v)) +} + +// LikeRankLTE applies the LTE predicate on the "like_rank" field. +func LikeRankLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldLikeRank, v)) +} + +// LikeRankIsNil applies the IsNil predicate on the "like_rank" field. +func LikeRankIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldLikeRank)) +} + +// LikeRankNotNil applies the NotNil predicate on the "like_rank" field. +func LikeRankNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldLikeRank)) +} + +// LikeAtEQ applies the EQ predicate on the "like_at" field. +func LikeAtEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldLikeAt, v)) +} + +// LikeAtNEQ applies the NEQ predicate on the "like_at" field. +func LikeAtNEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldNEQ(FieldLikeAt, v)) +} + +// LikeAtIn applies the In predicate on the "like_at" field. +func LikeAtIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldIn(FieldLikeAt, vs...)) +} + +// LikeAtNotIn applies the NotIn predicate on the "like_at" field. +func LikeAtNotIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldNotIn(FieldLikeAt, vs...)) +} + +// LikeAtGT applies the GT predicate on the "like_at" field. +func LikeAtGT(v time.Time) predicate.User { + return predicate.User(sql.FieldGT(FieldLikeAt, v)) +} + +// LikeAtGTE applies the GTE predicate on the "like_at" field. +func LikeAtGTE(v time.Time) predicate.User { + return predicate.User(sql.FieldGTE(FieldLikeAt, v)) +} + +// LikeAtLT applies the LT predicate on the "like_at" field. +func LikeAtLT(v time.Time) predicate.User { + return predicate.User(sql.FieldLT(FieldLikeAt, v)) +} + +// LikeAtLTE applies the LTE predicate on the "like_at" field. +func LikeAtLTE(v time.Time) predicate.User { + return predicate.User(sql.FieldLTE(FieldLikeAt, v)) +} + +// LikeAtIsNil applies the IsNil predicate on the "like_at" field. +func LikeAtIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldLikeAt)) +} + +// LikeAtNotNil applies the NotNil predicate on the "like_at" field. +func LikeAtNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldLikeAt)) +} + +// TenEQ applies the EQ predicate on the "ten" field. +func TenEQ(v bool) predicate.User { + return predicate.User(sql.FieldEQ(FieldTen, v)) +} + +// TenNEQ applies the NEQ predicate on the "ten" field. +func TenNEQ(v bool) predicate.User { + return predicate.User(sql.FieldNEQ(FieldTen, v)) +} + +// TenIsNil applies the IsNil predicate on the "ten" field. +func TenIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldTen)) +} + +// TenNotNil applies the NotNil predicate on the "ten" field. +func TenNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldTen)) +} + +// TenSuEQ applies the EQ predicate on the "ten_su" field. +func TenSuEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenSu, v)) +} + +// TenSuNEQ applies the NEQ predicate on the "ten_su" field. +func TenSuNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldTenSu, v)) +} + +// TenSuIn applies the In predicate on the "ten_su" field. +func TenSuIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldTenSu, vs...)) +} + +// TenSuNotIn applies the NotIn predicate on the "ten_su" field. +func TenSuNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldTenSu, vs...)) +} + +// TenSuGT applies the GT predicate on the "ten_su" field. +func TenSuGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldTenSu, v)) +} + +// TenSuGTE applies the GTE predicate on the "ten_su" field. +func TenSuGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldTenSu, v)) +} + +// TenSuLT applies the LT predicate on the "ten_su" field. +func TenSuLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldTenSu, v)) +} + +// TenSuLTE applies the LTE predicate on the "ten_su" field. +func TenSuLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldTenSu, v)) +} + +// TenSuIsNil applies the IsNil predicate on the "ten_su" field. +func TenSuIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldTenSu)) +} + +// TenSuNotNil applies the NotNil predicate on the "ten_su" field. +func TenSuNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldTenSu)) +} + +// TenKaiEQ applies the EQ predicate on the "ten_kai" field. +func TenKaiEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenKai, v)) +} + +// TenKaiNEQ applies the NEQ predicate on the "ten_kai" field. +func TenKaiNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldTenKai, v)) +} + +// TenKaiIn applies the In predicate on the "ten_kai" field. +func TenKaiIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldTenKai, vs...)) +} + +// TenKaiNotIn applies the NotIn predicate on the "ten_kai" field. +func TenKaiNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldTenKai, vs...)) +} + +// TenKaiGT applies the GT predicate on the "ten_kai" field. +func TenKaiGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldTenKai, v)) +} + +// TenKaiGTE applies the GTE predicate on the "ten_kai" field. +func TenKaiGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldTenKai, v)) +} + +// TenKaiLT applies the LT predicate on the "ten_kai" field. +func TenKaiLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldTenKai, v)) +} + +// TenKaiLTE applies the LTE predicate on the "ten_kai" field. +func TenKaiLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldTenKai, v)) +} + +// TenKaiIsNil applies the IsNil predicate on the "ten_kai" field. +func TenKaiIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldTenKai)) +} + +// TenKaiNotNil applies the NotNil predicate on the "ten_kai" field. +func TenKaiNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldTenKai)) +} + +// AitenEQ applies the EQ predicate on the "aiten" field. +func AitenEQ(v int) predicate.User { + return predicate.User(sql.FieldEQ(FieldAiten, v)) +} + +// AitenNEQ applies the NEQ predicate on the "aiten" field. +func AitenNEQ(v int) predicate.User { + return predicate.User(sql.FieldNEQ(FieldAiten, v)) +} + +// AitenIn applies the In predicate on the "aiten" field. +func AitenIn(vs ...int) predicate.User { + return predicate.User(sql.FieldIn(FieldAiten, vs...)) +} + +// AitenNotIn applies the NotIn predicate on the "aiten" field. +func AitenNotIn(vs ...int) predicate.User { + return predicate.User(sql.FieldNotIn(FieldAiten, vs...)) +} + +// AitenGT applies the GT predicate on the "aiten" field. +func AitenGT(v int) predicate.User { + return predicate.User(sql.FieldGT(FieldAiten, v)) +} + +// AitenGTE applies the GTE predicate on the "aiten" field. +func AitenGTE(v int) predicate.User { + return predicate.User(sql.FieldGTE(FieldAiten, v)) +} + +// AitenLT applies the LT predicate on the "aiten" field. +func AitenLT(v int) predicate.User { + return predicate.User(sql.FieldLT(FieldAiten, v)) +} + +// AitenLTE applies the LTE predicate on the "aiten" field. +func AitenLTE(v int) predicate.User { + return predicate.User(sql.FieldLTE(FieldAiten, v)) +} + +// AitenIsNil applies the IsNil predicate on the "aiten" field. +func AitenIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldAiten)) +} + +// AitenNotNil applies the NotNil predicate on the "aiten" field. +func AitenNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldAiten)) +} + +// TenCardEQ applies the EQ predicate on the "ten_card" field. +func TenCardEQ(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenCard, v)) +} + +// TenCardNEQ applies the NEQ predicate on the "ten_card" field. +func TenCardNEQ(v string) predicate.User { + return predicate.User(sql.FieldNEQ(FieldTenCard, v)) +} + +// TenCardIn applies the In predicate on the "ten_card" field. +func TenCardIn(vs ...string) predicate.User { + return predicate.User(sql.FieldIn(FieldTenCard, vs...)) +} + +// TenCardNotIn applies the NotIn predicate on the "ten_card" field. +func TenCardNotIn(vs ...string) predicate.User { + return predicate.User(sql.FieldNotIn(FieldTenCard, vs...)) +} + +// TenCardGT applies the GT predicate on the "ten_card" field. +func TenCardGT(v string) predicate.User { + return predicate.User(sql.FieldGT(FieldTenCard, v)) +} + +// TenCardGTE applies the GTE predicate on the "ten_card" field. +func TenCardGTE(v string) predicate.User { + return predicate.User(sql.FieldGTE(FieldTenCard, v)) +} + +// TenCardLT applies the LT predicate on the "ten_card" field. +func TenCardLT(v string) predicate.User { + return predicate.User(sql.FieldLT(FieldTenCard, v)) +} + +// TenCardLTE applies the LTE predicate on the "ten_card" field. +func TenCardLTE(v string) predicate.User { + return predicate.User(sql.FieldLTE(FieldTenCard, v)) +} + +// TenCardContains applies the Contains predicate on the "ten_card" field. +func TenCardContains(v string) predicate.User { + return predicate.User(sql.FieldContains(FieldTenCard, v)) +} + +// TenCardHasPrefix applies the HasPrefix predicate on the "ten_card" field. +func TenCardHasPrefix(v string) predicate.User { + return predicate.User(sql.FieldHasPrefix(FieldTenCard, v)) +} + +// TenCardHasSuffix applies the HasSuffix predicate on the "ten_card" field. +func TenCardHasSuffix(v string) predicate.User { + return predicate.User(sql.FieldHasSuffix(FieldTenCard, v)) +} + +// TenCardIsNil applies the IsNil predicate on the "ten_card" field. +func TenCardIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldTenCard)) +} + +// TenCardNotNil applies the NotNil predicate on the "ten_card" field. +func TenCardNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldTenCard)) +} + +// TenCardEqualFold applies the EqualFold predicate on the "ten_card" field. +func TenCardEqualFold(v string) predicate.User { + return predicate.User(sql.FieldEqualFold(FieldTenCard, v)) +} + +// TenCardContainsFold applies the ContainsFold predicate on the "ten_card" field. +func TenCardContainsFold(v string) predicate.User { + return predicate.User(sql.FieldContainsFold(FieldTenCard, v)) +} + +// TenDeleteEQ applies the EQ predicate on the "ten_delete" field. +func TenDeleteEQ(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenDelete, v)) +} + +// TenDeleteNEQ applies the NEQ predicate on the "ten_delete" field. +func TenDeleteNEQ(v string) predicate.User { + return predicate.User(sql.FieldNEQ(FieldTenDelete, v)) +} + +// TenDeleteIn applies the In predicate on the "ten_delete" field. +func TenDeleteIn(vs ...string) predicate.User { + return predicate.User(sql.FieldIn(FieldTenDelete, vs...)) +} + +// TenDeleteNotIn applies the NotIn predicate on the "ten_delete" field. +func TenDeleteNotIn(vs ...string) predicate.User { + return predicate.User(sql.FieldNotIn(FieldTenDelete, vs...)) +} + +// TenDeleteGT applies the GT predicate on the "ten_delete" field. +func TenDeleteGT(v string) predicate.User { + return predicate.User(sql.FieldGT(FieldTenDelete, v)) +} + +// TenDeleteGTE applies the GTE predicate on the "ten_delete" field. +func TenDeleteGTE(v string) predicate.User { + return predicate.User(sql.FieldGTE(FieldTenDelete, v)) +} + +// TenDeleteLT applies the LT predicate on the "ten_delete" field. +func TenDeleteLT(v string) predicate.User { + return predicate.User(sql.FieldLT(FieldTenDelete, v)) +} + +// TenDeleteLTE applies the LTE predicate on the "ten_delete" field. +func TenDeleteLTE(v string) predicate.User { + return predicate.User(sql.FieldLTE(FieldTenDelete, v)) +} + +// TenDeleteContains applies the Contains predicate on the "ten_delete" field. +func TenDeleteContains(v string) predicate.User { + return predicate.User(sql.FieldContains(FieldTenDelete, v)) +} + +// TenDeleteHasPrefix applies the HasPrefix predicate on the "ten_delete" field. +func TenDeleteHasPrefix(v string) predicate.User { + return predicate.User(sql.FieldHasPrefix(FieldTenDelete, v)) +} + +// TenDeleteHasSuffix applies the HasSuffix predicate on the "ten_delete" field. +func TenDeleteHasSuffix(v string) predicate.User { + return predicate.User(sql.FieldHasSuffix(FieldTenDelete, v)) +} + +// TenDeleteIsNil applies the IsNil predicate on the "ten_delete" field. +func TenDeleteIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldTenDelete)) +} + +// TenDeleteNotNil applies the NotNil predicate on the "ten_delete" field. +func TenDeleteNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldTenDelete)) +} + +// TenDeleteEqualFold applies the EqualFold predicate on the "ten_delete" field. +func TenDeleteEqualFold(v string) predicate.User { + return predicate.User(sql.FieldEqualFold(FieldTenDelete, v)) +} + +// TenDeleteContainsFold applies the ContainsFold predicate on the "ten_delete" field. +func TenDeleteContainsFold(v string) predicate.User { + return predicate.User(sql.FieldContainsFold(FieldTenDelete, v)) +} + +// TenPostEQ applies the EQ predicate on the "ten_post" field. +func TenPostEQ(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenPost, v)) +} + +// TenPostNEQ applies the NEQ predicate on the "ten_post" field. +func TenPostNEQ(v string) predicate.User { + return predicate.User(sql.FieldNEQ(FieldTenPost, v)) +} + +// TenPostIn applies the In predicate on the "ten_post" field. +func TenPostIn(vs ...string) predicate.User { + return predicate.User(sql.FieldIn(FieldTenPost, vs...)) +} + +// TenPostNotIn applies the NotIn predicate on the "ten_post" field. +func TenPostNotIn(vs ...string) predicate.User { + return predicate.User(sql.FieldNotIn(FieldTenPost, vs...)) +} + +// TenPostGT applies the GT predicate on the "ten_post" field. +func TenPostGT(v string) predicate.User { + return predicate.User(sql.FieldGT(FieldTenPost, v)) +} + +// TenPostGTE applies the GTE predicate on the "ten_post" field. +func TenPostGTE(v string) predicate.User { + return predicate.User(sql.FieldGTE(FieldTenPost, v)) +} + +// TenPostLT applies the LT predicate on the "ten_post" field. +func TenPostLT(v string) predicate.User { + return predicate.User(sql.FieldLT(FieldTenPost, v)) +} + +// TenPostLTE applies the LTE predicate on the "ten_post" field. +func TenPostLTE(v string) predicate.User { + return predicate.User(sql.FieldLTE(FieldTenPost, v)) +} + +// TenPostContains applies the Contains predicate on the "ten_post" field. +func TenPostContains(v string) predicate.User { + return predicate.User(sql.FieldContains(FieldTenPost, v)) +} + +// TenPostHasPrefix applies the HasPrefix predicate on the "ten_post" field. +func TenPostHasPrefix(v string) predicate.User { + return predicate.User(sql.FieldHasPrefix(FieldTenPost, v)) +} + +// TenPostHasSuffix applies the HasSuffix predicate on the "ten_post" field. +func TenPostHasSuffix(v string) predicate.User { + return predicate.User(sql.FieldHasSuffix(FieldTenPost, v)) +} + +// TenPostIsNil applies the IsNil predicate on the "ten_post" field. +func TenPostIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldTenPost)) +} + +// TenPostNotNil applies the NotNil predicate on the "ten_post" field. +func TenPostNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldTenPost)) +} + +// TenPostEqualFold applies the EqualFold predicate on the "ten_post" field. +func TenPostEqualFold(v string) predicate.User { + return predicate.User(sql.FieldEqualFold(FieldTenPost, v)) +} + +// TenPostContainsFold applies the ContainsFold predicate on the "ten_post" field. +func TenPostContainsFold(v string) predicate.User { + return predicate.User(sql.FieldContainsFold(FieldTenPost, v)) +} + +// TenGetEQ applies the EQ predicate on the "ten_get" field. +func TenGetEQ(v string) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenGet, v)) +} + +// TenGetNEQ applies the NEQ predicate on the "ten_get" field. +func TenGetNEQ(v string) predicate.User { + return predicate.User(sql.FieldNEQ(FieldTenGet, v)) +} + +// TenGetIn applies the In predicate on the "ten_get" field. +func TenGetIn(vs ...string) predicate.User { + return predicate.User(sql.FieldIn(FieldTenGet, vs...)) +} + +// TenGetNotIn applies the NotIn predicate on the "ten_get" field. +func TenGetNotIn(vs ...string) predicate.User { + return predicate.User(sql.FieldNotIn(FieldTenGet, vs...)) +} + +// TenGetGT applies the GT predicate on the "ten_get" field. +func TenGetGT(v string) predicate.User { + return predicate.User(sql.FieldGT(FieldTenGet, v)) +} + +// TenGetGTE applies the GTE predicate on the "ten_get" field. +func TenGetGTE(v string) predicate.User { + return predicate.User(sql.FieldGTE(FieldTenGet, v)) +} + +// TenGetLT applies the LT predicate on the "ten_get" field. +func TenGetLT(v string) predicate.User { + return predicate.User(sql.FieldLT(FieldTenGet, v)) +} + +// TenGetLTE applies the LTE predicate on the "ten_get" field. +func TenGetLTE(v string) predicate.User { + return predicate.User(sql.FieldLTE(FieldTenGet, v)) +} + +// TenGetContains applies the Contains predicate on the "ten_get" field. +func TenGetContains(v string) predicate.User { + return predicate.User(sql.FieldContains(FieldTenGet, v)) +} + +// TenGetHasPrefix applies the HasPrefix predicate on the "ten_get" field. +func TenGetHasPrefix(v string) predicate.User { + return predicate.User(sql.FieldHasPrefix(FieldTenGet, v)) +} + +// TenGetHasSuffix applies the HasSuffix predicate on the "ten_get" field. +func TenGetHasSuffix(v string) predicate.User { + return predicate.User(sql.FieldHasSuffix(FieldTenGet, v)) +} + +// TenGetIsNil applies the IsNil predicate on the "ten_get" field. +func TenGetIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldTenGet)) +} + +// TenGetNotNil applies the NotNil predicate on the "ten_get" field. +func TenGetNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldTenGet)) +} + +// TenGetEqualFold applies the EqualFold predicate on the "ten_get" field. +func TenGetEqualFold(v string) predicate.User { + return predicate.User(sql.FieldEqualFold(FieldTenGet, v)) +} + +// TenGetContainsFold applies the ContainsFold predicate on the "ten_get" field. +func TenGetContainsFold(v string) predicate.User { + return predicate.User(sql.FieldContainsFold(FieldTenGet, v)) +} + +// TenAtEQ applies the EQ predicate on the "ten_at" field. +func TenAtEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldEQ(FieldTenAt, v)) +} + +// TenAtNEQ applies the NEQ predicate on the "ten_at" field. +func TenAtNEQ(v time.Time) predicate.User { + return predicate.User(sql.FieldNEQ(FieldTenAt, v)) +} + +// TenAtIn applies the In predicate on the "ten_at" field. +func TenAtIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldIn(FieldTenAt, vs...)) +} + +// TenAtNotIn applies the NotIn predicate on the "ten_at" field. +func TenAtNotIn(vs ...time.Time) predicate.User { + return predicate.User(sql.FieldNotIn(FieldTenAt, vs...)) +} + +// TenAtGT applies the GT predicate on the "ten_at" field. +func TenAtGT(v time.Time) predicate.User { + return predicate.User(sql.FieldGT(FieldTenAt, v)) +} + +// TenAtGTE applies the GTE predicate on the "ten_at" field. +func TenAtGTE(v time.Time) predicate.User { + return predicate.User(sql.FieldGTE(FieldTenAt, v)) +} + +// TenAtLT applies the LT predicate on the "ten_at" field. +func TenAtLT(v time.Time) predicate.User { + return predicate.User(sql.FieldLT(FieldTenAt, v)) +} + +// TenAtLTE applies the LTE predicate on the "ten_at" field. +func TenAtLTE(v time.Time) predicate.User { + return predicate.User(sql.FieldLTE(FieldTenAt, v)) +} + +// TenAtIsNil applies the IsNil predicate on the "ten_at" field. +func TenAtIsNil() predicate.User { + return predicate.User(sql.FieldIsNull(FieldTenAt)) +} + +// TenAtNotNil applies the NotNil predicate on the "ten_at" field. +func TenAtNotNil() predicate.User { + return predicate.User(sql.FieldNotNull(FieldTenAt)) +} + // NextEQ applies the EQ predicate on the "next" field. func NextEQ(v string) predicate.User { return predicate.User(sql.FieldEQ(FieldNext, v)) diff --git a/ent/user_create.go b/ent/user_create.go index 4891d56..4f2c0ad 100644 --- a/ent/user_create.go +++ b/ent/user_create.go @@ -103,6 +103,216 @@ func (uc *UserCreate) SetNillableUpdatedAt(t *time.Time) *UserCreate { return uc } +// SetRaidAt sets the "raid_at" field. +func (uc *UserCreate) SetRaidAt(t time.Time) *UserCreate { + uc.mutation.SetRaidAt(t) + return uc +} + +// SetNillableRaidAt sets the "raid_at" field if the given value is not nil. +func (uc *UserCreate) SetNillableRaidAt(t *time.Time) *UserCreate { + if t != nil { + uc.SetRaidAt(*t) + } + return uc +} + +// SetLuck sets the "luck" field. +func (uc *UserCreate) SetLuck(i int) *UserCreate { + uc.mutation.SetLuck(i) + return uc +} + +// SetNillableLuck sets the "luck" field if the given value is not nil. +func (uc *UserCreate) SetNillableLuck(i *int) *UserCreate { + if i != nil { + uc.SetLuck(*i) + } + return uc +} + +// SetLuckAt sets the "luck_at" field. +func (uc *UserCreate) SetLuckAt(t time.Time) *UserCreate { + uc.mutation.SetLuckAt(t) + return uc +} + +// SetNillableLuckAt sets the "luck_at" field if the given value is not nil. +func (uc *UserCreate) SetNillableLuckAt(t *time.Time) *UserCreate { + if t != nil { + uc.SetLuckAt(*t) + } + return uc +} + +// SetLike sets the "like" field. +func (uc *UserCreate) SetLike(i int) *UserCreate { + uc.mutation.SetLike(i) + return uc +} + +// SetNillableLike sets the "like" field if the given value is not nil. +func (uc *UserCreate) SetNillableLike(i *int) *UserCreate { + if i != nil { + uc.SetLike(*i) + } + return uc +} + +// SetLikeRank sets the "like_rank" field. +func (uc *UserCreate) SetLikeRank(i int) *UserCreate { + uc.mutation.SetLikeRank(i) + return uc +} + +// SetNillableLikeRank sets the "like_rank" field if the given value is not nil. +func (uc *UserCreate) SetNillableLikeRank(i *int) *UserCreate { + if i != nil { + uc.SetLikeRank(*i) + } + return uc +} + +// SetLikeAt sets the "like_at" field. +func (uc *UserCreate) SetLikeAt(t time.Time) *UserCreate { + uc.mutation.SetLikeAt(t) + return uc +} + +// SetNillableLikeAt sets the "like_at" field if the given value is not nil. +func (uc *UserCreate) SetNillableLikeAt(t *time.Time) *UserCreate { + if t != nil { + uc.SetLikeAt(*t) + } + return uc +} + +// SetTen sets the "ten" field. +func (uc *UserCreate) SetTen(b bool) *UserCreate { + uc.mutation.SetTen(b) + return uc +} + +// SetNillableTen sets the "ten" field if the given value is not nil. +func (uc *UserCreate) SetNillableTen(b *bool) *UserCreate { + if b != nil { + uc.SetTen(*b) + } + return uc +} + +// SetTenSu sets the "ten_su" field. +func (uc *UserCreate) SetTenSu(i int) *UserCreate { + uc.mutation.SetTenSu(i) + return uc +} + +// SetNillableTenSu sets the "ten_su" field if the given value is not nil. +func (uc *UserCreate) SetNillableTenSu(i *int) *UserCreate { + if i != nil { + uc.SetTenSu(*i) + } + return uc +} + +// SetTenKai sets the "ten_kai" field. +func (uc *UserCreate) SetTenKai(i int) *UserCreate { + uc.mutation.SetTenKai(i) + return uc +} + +// SetNillableTenKai sets the "ten_kai" field if the given value is not nil. +func (uc *UserCreate) SetNillableTenKai(i *int) *UserCreate { + if i != nil { + uc.SetTenKai(*i) + } + return uc +} + +// SetAiten sets the "aiten" field. +func (uc *UserCreate) SetAiten(i int) *UserCreate { + uc.mutation.SetAiten(i) + return uc +} + +// SetNillableAiten sets the "aiten" field if the given value is not nil. +func (uc *UserCreate) SetNillableAiten(i *int) *UserCreate { + if i != nil { + uc.SetAiten(*i) + } + return uc +} + +// SetTenCard sets the "ten_card" field. +func (uc *UserCreate) SetTenCard(s string) *UserCreate { + uc.mutation.SetTenCard(s) + return uc +} + +// SetNillableTenCard sets the "ten_card" field if the given value is not nil. +func (uc *UserCreate) SetNillableTenCard(s *string) *UserCreate { + if s != nil { + uc.SetTenCard(*s) + } + return uc +} + +// SetTenDelete sets the "ten_delete" field. +func (uc *UserCreate) SetTenDelete(s string) *UserCreate { + uc.mutation.SetTenDelete(s) + return uc +} + +// SetNillableTenDelete sets the "ten_delete" field if the given value is not nil. +func (uc *UserCreate) SetNillableTenDelete(s *string) *UserCreate { + if s != nil { + uc.SetTenDelete(*s) + } + return uc +} + +// SetTenPost sets the "ten_post" field. +func (uc *UserCreate) SetTenPost(s string) *UserCreate { + uc.mutation.SetTenPost(s) + return uc +} + +// SetNillableTenPost sets the "ten_post" field if the given value is not nil. +func (uc *UserCreate) SetNillableTenPost(s *string) *UserCreate { + if s != nil { + uc.SetTenPost(*s) + } + return uc +} + +// SetTenGet sets the "ten_get" field. +func (uc *UserCreate) SetTenGet(s string) *UserCreate { + uc.mutation.SetTenGet(s) + return uc +} + +// SetNillableTenGet sets the "ten_get" field if the given value is not nil. +func (uc *UserCreate) SetNillableTenGet(s *string) *UserCreate { + if s != nil { + uc.SetTenGet(*s) + } + return uc +} + +// SetTenAt sets the "ten_at" field. +func (uc *UserCreate) SetTenAt(t time.Time) *UserCreate { + uc.mutation.SetTenAt(t) + return uc +} + +// SetNillableTenAt sets the "ten_at" field if the given value is not nil. +func (uc *UserCreate) SetNillableTenAt(t *time.Time) *UserCreate { + if t != nil { + uc.SetTenAt(*t) + } + return uc +} + // SetNext sets the "next" field. func (uc *UserCreate) SetNext(s string) *UserCreate { uc.mutation.SetNext(s) @@ -179,6 +389,22 @@ func (uc *UserCreate) defaults() { v := user.DefaultUpdatedAt() uc.mutation.SetUpdatedAt(v) } + if _, ok := uc.mutation.RaidAt(); !ok { + v := user.DefaultRaidAt() + uc.mutation.SetRaidAt(v) + } + if _, ok := uc.mutation.LuckAt(); !ok { + v := user.DefaultLuckAt() + uc.mutation.SetLuckAt(v) + } + if _, ok := uc.mutation.LikeAt(); !ok { + v := user.DefaultLikeAt() + uc.mutation.SetLikeAt(v) + } + if _, ok := uc.mutation.TenAt(); !ok { + v := user.DefaultTenAt() + uc.mutation.SetTenAt(v) + } if _, ok := uc.mutation.Next(); !ok { v := user.DefaultNext uc.mutation.SetNext(v) @@ -257,6 +483,66 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { _spec.SetField(user.FieldUpdatedAt, field.TypeTime, value) _node.UpdatedAt = value } + if value, ok := uc.mutation.RaidAt(); ok { + _spec.SetField(user.FieldRaidAt, field.TypeTime, value) + _node.RaidAt = value + } + if value, ok := uc.mutation.Luck(); ok { + _spec.SetField(user.FieldLuck, field.TypeInt, value) + _node.Luck = value + } + if value, ok := uc.mutation.LuckAt(); ok { + _spec.SetField(user.FieldLuckAt, field.TypeTime, value) + _node.LuckAt = value + } + if value, ok := uc.mutation.Like(); ok { + _spec.SetField(user.FieldLike, field.TypeInt, value) + _node.Like = value + } + if value, ok := uc.mutation.LikeRank(); ok { + _spec.SetField(user.FieldLikeRank, field.TypeInt, value) + _node.LikeRank = value + } + if value, ok := uc.mutation.LikeAt(); ok { + _spec.SetField(user.FieldLikeAt, field.TypeTime, value) + _node.LikeAt = value + } + if value, ok := uc.mutation.Ten(); ok { + _spec.SetField(user.FieldTen, field.TypeBool, value) + _node.Ten = value + } + if value, ok := uc.mutation.TenSu(); ok { + _spec.SetField(user.FieldTenSu, field.TypeInt, value) + _node.TenSu = value + } + if value, ok := uc.mutation.TenKai(); ok { + _spec.SetField(user.FieldTenKai, field.TypeInt, value) + _node.TenKai = value + } + if value, ok := uc.mutation.Aiten(); ok { + _spec.SetField(user.FieldAiten, field.TypeInt, value) + _node.Aiten = value + } + if value, ok := uc.mutation.TenCard(); ok { + _spec.SetField(user.FieldTenCard, field.TypeString, value) + _node.TenCard = value + } + if value, ok := uc.mutation.TenDelete(); ok { + _spec.SetField(user.FieldTenDelete, field.TypeString, value) + _node.TenDelete = value + } + if value, ok := uc.mutation.TenPost(); ok { + _spec.SetField(user.FieldTenPost, field.TypeString, value) + _node.TenPost = value + } + if value, ok := uc.mutation.TenGet(); ok { + _spec.SetField(user.FieldTenGet, field.TypeString, value) + _node.TenGet = value + } + if value, ok := uc.mutation.TenAt(); ok { + _spec.SetField(user.FieldTenAt, field.TypeTime, value) + _node.TenAt = value + } if value, ok := uc.mutation.Next(); ok { _spec.SetField(user.FieldNext, field.TypeString, value) _node.Next = value diff --git a/ent/user_update.go b/ent/user_update.go index 032931d..3c0160b 100644 --- a/ent/user_update.go +++ b/ent/user_update.go @@ -109,6 +109,348 @@ func (uu *UserUpdate) ClearUpdatedAt() *UserUpdate { return uu } +// SetRaidAt sets the "raid_at" field. +func (uu *UserUpdate) SetRaidAt(t time.Time) *UserUpdate { + uu.mutation.SetRaidAt(t) + return uu +} + +// SetNillableRaidAt sets the "raid_at" field if the given value is not nil. +func (uu *UserUpdate) SetNillableRaidAt(t *time.Time) *UserUpdate { + if t != nil { + uu.SetRaidAt(*t) + } + return uu +} + +// ClearRaidAt clears the value of the "raid_at" field. +func (uu *UserUpdate) ClearRaidAt() *UserUpdate { + uu.mutation.ClearRaidAt() + return uu +} + +// SetLuck sets the "luck" field. +func (uu *UserUpdate) SetLuck(i int) *UserUpdate { + uu.mutation.ResetLuck() + uu.mutation.SetLuck(i) + return uu +} + +// SetNillableLuck sets the "luck" field if the given value is not nil. +func (uu *UserUpdate) SetNillableLuck(i *int) *UserUpdate { + if i != nil { + uu.SetLuck(*i) + } + return uu +} + +// AddLuck adds i to the "luck" field. +func (uu *UserUpdate) AddLuck(i int) *UserUpdate { + uu.mutation.AddLuck(i) + return uu +} + +// ClearLuck clears the value of the "luck" field. +func (uu *UserUpdate) ClearLuck() *UserUpdate { + uu.mutation.ClearLuck() + return uu +} + +// SetLuckAt sets the "luck_at" field. +func (uu *UserUpdate) SetLuckAt(t time.Time) *UserUpdate { + uu.mutation.SetLuckAt(t) + return uu +} + +// SetNillableLuckAt sets the "luck_at" field if the given value is not nil. +func (uu *UserUpdate) SetNillableLuckAt(t *time.Time) *UserUpdate { + if t != nil { + uu.SetLuckAt(*t) + } + return uu +} + +// ClearLuckAt clears the value of the "luck_at" field. +func (uu *UserUpdate) ClearLuckAt() *UserUpdate { + uu.mutation.ClearLuckAt() + return uu +} + +// SetLike sets the "like" field. +func (uu *UserUpdate) SetLike(i int) *UserUpdate { + uu.mutation.ResetLike() + uu.mutation.SetLike(i) + return uu +} + +// SetNillableLike sets the "like" field if the given value is not nil. +func (uu *UserUpdate) SetNillableLike(i *int) *UserUpdate { + if i != nil { + uu.SetLike(*i) + } + return uu +} + +// AddLike adds i to the "like" field. +func (uu *UserUpdate) AddLike(i int) *UserUpdate { + uu.mutation.AddLike(i) + return uu +} + +// ClearLike clears the value of the "like" field. +func (uu *UserUpdate) ClearLike() *UserUpdate { + uu.mutation.ClearLike() + return uu +} + +// SetLikeRank sets the "like_rank" field. +func (uu *UserUpdate) SetLikeRank(i int) *UserUpdate { + uu.mutation.ResetLikeRank() + uu.mutation.SetLikeRank(i) + return uu +} + +// SetNillableLikeRank sets the "like_rank" field if the given value is not nil. +func (uu *UserUpdate) SetNillableLikeRank(i *int) *UserUpdate { + if i != nil { + uu.SetLikeRank(*i) + } + return uu +} + +// AddLikeRank adds i to the "like_rank" field. +func (uu *UserUpdate) AddLikeRank(i int) *UserUpdate { + uu.mutation.AddLikeRank(i) + return uu +} + +// ClearLikeRank clears the value of the "like_rank" field. +func (uu *UserUpdate) ClearLikeRank() *UserUpdate { + uu.mutation.ClearLikeRank() + return uu +} + +// SetLikeAt sets the "like_at" field. +func (uu *UserUpdate) SetLikeAt(t time.Time) *UserUpdate { + uu.mutation.SetLikeAt(t) + return uu +} + +// SetNillableLikeAt sets the "like_at" field if the given value is not nil. +func (uu *UserUpdate) SetNillableLikeAt(t *time.Time) *UserUpdate { + if t != nil { + uu.SetLikeAt(*t) + } + return uu +} + +// ClearLikeAt clears the value of the "like_at" field. +func (uu *UserUpdate) ClearLikeAt() *UserUpdate { + uu.mutation.ClearLikeAt() + return uu +} + +// SetTen sets the "ten" field. +func (uu *UserUpdate) SetTen(b bool) *UserUpdate { + uu.mutation.SetTen(b) + return uu +} + +// SetNillableTen sets the "ten" field if the given value is not nil. +func (uu *UserUpdate) SetNillableTen(b *bool) *UserUpdate { + if b != nil { + uu.SetTen(*b) + } + return uu +} + +// ClearTen clears the value of the "ten" field. +func (uu *UserUpdate) ClearTen() *UserUpdate { + uu.mutation.ClearTen() + return uu +} + +// SetTenSu sets the "ten_su" field. +func (uu *UserUpdate) SetTenSu(i int) *UserUpdate { + uu.mutation.ResetTenSu() + uu.mutation.SetTenSu(i) + return uu +} + +// SetNillableTenSu sets the "ten_su" field if the given value is not nil. +func (uu *UserUpdate) SetNillableTenSu(i *int) *UserUpdate { + if i != nil { + uu.SetTenSu(*i) + } + return uu +} + +// AddTenSu adds i to the "ten_su" field. +func (uu *UserUpdate) AddTenSu(i int) *UserUpdate { + uu.mutation.AddTenSu(i) + return uu +} + +// ClearTenSu clears the value of the "ten_su" field. +func (uu *UserUpdate) ClearTenSu() *UserUpdate { + uu.mutation.ClearTenSu() + return uu +} + +// SetTenKai sets the "ten_kai" field. +func (uu *UserUpdate) SetTenKai(i int) *UserUpdate { + uu.mutation.ResetTenKai() + uu.mutation.SetTenKai(i) + return uu +} + +// SetNillableTenKai sets the "ten_kai" field if the given value is not nil. +func (uu *UserUpdate) SetNillableTenKai(i *int) *UserUpdate { + if i != nil { + uu.SetTenKai(*i) + } + return uu +} + +// AddTenKai adds i to the "ten_kai" field. +func (uu *UserUpdate) AddTenKai(i int) *UserUpdate { + uu.mutation.AddTenKai(i) + return uu +} + +// ClearTenKai clears the value of the "ten_kai" field. +func (uu *UserUpdate) ClearTenKai() *UserUpdate { + uu.mutation.ClearTenKai() + return uu +} + +// SetAiten sets the "aiten" field. +func (uu *UserUpdate) SetAiten(i int) *UserUpdate { + uu.mutation.ResetAiten() + uu.mutation.SetAiten(i) + return uu +} + +// SetNillableAiten sets the "aiten" field if the given value is not nil. +func (uu *UserUpdate) SetNillableAiten(i *int) *UserUpdate { + if i != nil { + uu.SetAiten(*i) + } + return uu +} + +// AddAiten adds i to the "aiten" field. +func (uu *UserUpdate) AddAiten(i int) *UserUpdate { + uu.mutation.AddAiten(i) + return uu +} + +// ClearAiten clears the value of the "aiten" field. +func (uu *UserUpdate) ClearAiten() *UserUpdate { + uu.mutation.ClearAiten() + return uu +} + +// SetTenCard sets the "ten_card" field. +func (uu *UserUpdate) SetTenCard(s string) *UserUpdate { + uu.mutation.SetTenCard(s) + return uu +} + +// SetNillableTenCard sets the "ten_card" field if the given value is not nil. +func (uu *UserUpdate) SetNillableTenCard(s *string) *UserUpdate { + if s != nil { + uu.SetTenCard(*s) + } + return uu +} + +// ClearTenCard clears the value of the "ten_card" field. +func (uu *UserUpdate) ClearTenCard() *UserUpdate { + uu.mutation.ClearTenCard() + return uu +} + +// SetTenDelete sets the "ten_delete" field. +func (uu *UserUpdate) SetTenDelete(s string) *UserUpdate { + uu.mutation.SetTenDelete(s) + return uu +} + +// SetNillableTenDelete sets the "ten_delete" field if the given value is not nil. +func (uu *UserUpdate) SetNillableTenDelete(s *string) *UserUpdate { + if s != nil { + uu.SetTenDelete(*s) + } + return uu +} + +// ClearTenDelete clears the value of the "ten_delete" field. +func (uu *UserUpdate) ClearTenDelete() *UserUpdate { + uu.mutation.ClearTenDelete() + return uu +} + +// SetTenPost sets the "ten_post" field. +func (uu *UserUpdate) SetTenPost(s string) *UserUpdate { + uu.mutation.SetTenPost(s) + return uu +} + +// SetNillableTenPost sets the "ten_post" field if the given value is not nil. +func (uu *UserUpdate) SetNillableTenPost(s *string) *UserUpdate { + if s != nil { + uu.SetTenPost(*s) + } + return uu +} + +// ClearTenPost clears the value of the "ten_post" field. +func (uu *UserUpdate) ClearTenPost() *UserUpdate { + uu.mutation.ClearTenPost() + return uu +} + +// SetTenGet sets the "ten_get" field. +func (uu *UserUpdate) SetTenGet(s string) *UserUpdate { + uu.mutation.SetTenGet(s) + return uu +} + +// SetNillableTenGet sets the "ten_get" field if the given value is not nil. +func (uu *UserUpdate) SetNillableTenGet(s *string) *UserUpdate { + if s != nil { + uu.SetTenGet(*s) + } + return uu +} + +// ClearTenGet clears the value of the "ten_get" field. +func (uu *UserUpdate) ClearTenGet() *UserUpdate { + uu.mutation.ClearTenGet() + return uu +} + +// SetTenAt sets the "ten_at" field. +func (uu *UserUpdate) SetTenAt(t time.Time) *UserUpdate { + uu.mutation.SetTenAt(t) + return uu +} + +// SetNillableTenAt sets the "ten_at" field if the given value is not nil. +func (uu *UserUpdate) SetNillableTenAt(t *time.Time) *UserUpdate { + if t != nil { + uu.SetTenAt(*t) + } + return uu +} + +// ClearTenAt clears the value of the "ten_at" field. +func (uu *UserUpdate) ClearTenAt() *UserUpdate { + uu.mutation.ClearTenAt() + return uu +} + // SetNext sets the "next" field. func (uu *UserUpdate) SetNext(s string) *UserUpdate { uu.mutation.SetNext(s) @@ -233,6 +575,114 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) { if uu.mutation.UpdatedAtCleared() { _spec.ClearField(user.FieldUpdatedAt, field.TypeTime) } + if value, ok := uu.mutation.RaidAt(); ok { + _spec.SetField(user.FieldRaidAt, field.TypeTime, value) + } + if uu.mutation.RaidAtCleared() { + _spec.ClearField(user.FieldRaidAt, field.TypeTime) + } + if value, ok := uu.mutation.Luck(); ok { + _spec.SetField(user.FieldLuck, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedLuck(); ok { + _spec.AddField(user.FieldLuck, field.TypeInt, value) + } + if uu.mutation.LuckCleared() { + _spec.ClearField(user.FieldLuck, field.TypeInt) + } + if value, ok := uu.mutation.LuckAt(); ok { + _spec.SetField(user.FieldLuckAt, field.TypeTime, value) + } + if uu.mutation.LuckAtCleared() { + _spec.ClearField(user.FieldLuckAt, field.TypeTime) + } + if value, ok := uu.mutation.Like(); ok { + _spec.SetField(user.FieldLike, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedLike(); ok { + _spec.AddField(user.FieldLike, field.TypeInt, value) + } + if uu.mutation.LikeCleared() { + _spec.ClearField(user.FieldLike, field.TypeInt) + } + if value, ok := uu.mutation.LikeRank(); ok { + _spec.SetField(user.FieldLikeRank, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedLikeRank(); ok { + _spec.AddField(user.FieldLikeRank, field.TypeInt, value) + } + if uu.mutation.LikeRankCleared() { + _spec.ClearField(user.FieldLikeRank, field.TypeInt) + } + if value, ok := uu.mutation.LikeAt(); ok { + _spec.SetField(user.FieldLikeAt, field.TypeTime, value) + } + if uu.mutation.LikeAtCleared() { + _spec.ClearField(user.FieldLikeAt, field.TypeTime) + } + if value, ok := uu.mutation.Ten(); ok { + _spec.SetField(user.FieldTen, field.TypeBool, value) + } + if uu.mutation.TenCleared() { + _spec.ClearField(user.FieldTen, field.TypeBool) + } + if value, ok := uu.mutation.TenSu(); ok { + _spec.SetField(user.FieldTenSu, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedTenSu(); ok { + _spec.AddField(user.FieldTenSu, field.TypeInt, value) + } + if uu.mutation.TenSuCleared() { + _spec.ClearField(user.FieldTenSu, field.TypeInt) + } + if value, ok := uu.mutation.TenKai(); ok { + _spec.SetField(user.FieldTenKai, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedTenKai(); ok { + _spec.AddField(user.FieldTenKai, field.TypeInt, value) + } + if uu.mutation.TenKaiCleared() { + _spec.ClearField(user.FieldTenKai, field.TypeInt) + } + if value, ok := uu.mutation.Aiten(); ok { + _spec.SetField(user.FieldAiten, field.TypeInt, value) + } + if value, ok := uu.mutation.AddedAiten(); ok { + _spec.AddField(user.FieldAiten, field.TypeInt, value) + } + if uu.mutation.AitenCleared() { + _spec.ClearField(user.FieldAiten, field.TypeInt) + } + if value, ok := uu.mutation.TenCard(); ok { + _spec.SetField(user.FieldTenCard, field.TypeString, value) + } + if uu.mutation.TenCardCleared() { + _spec.ClearField(user.FieldTenCard, field.TypeString) + } + if value, ok := uu.mutation.TenDelete(); ok { + _spec.SetField(user.FieldTenDelete, field.TypeString, value) + } + if uu.mutation.TenDeleteCleared() { + _spec.ClearField(user.FieldTenDelete, field.TypeString) + } + if value, ok := uu.mutation.TenPost(); ok { + _spec.SetField(user.FieldTenPost, field.TypeString, value) + } + if uu.mutation.TenPostCleared() { + _spec.ClearField(user.FieldTenPost, field.TypeString) + } + if value, ok := uu.mutation.TenGet(); ok { + _spec.SetField(user.FieldTenGet, field.TypeString, value) + } + if uu.mutation.TenGetCleared() { + _spec.ClearField(user.FieldTenGet, field.TypeString) + } + if value, ok := uu.mutation.TenAt(); ok { + _spec.SetField(user.FieldTenAt, field.TypeTime, value) + } + if uu.mutation.TenAtCleared() { + _spec.ClearField(user.FieldTenAt, field.TypeTime) + } if value, ok := uu.mutation.Next(); ok { _spec.SetField(user.FieldNext, field.TypeString, value) } @@ -384,6 +834,348 @@ func (uuo *UserUpdateOne) ClearUpdatedAt() *UserUpdateOne { return uuo } +// SetRaidAt sets the "raid_at" field. +func (uuo *UserUpdateOne) SetRaidAt(t time.Time) *UserUpdateOne { + uuo.mutation.SetRaidAt(t) + return uuo +} + +// SetNillableRaidAt sets the "raid_at" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableRaidAt(t *time.Time) *UserUpdateOne { + if t != nil { + uuo.SetRaidAt(*t) + } + return uuo +} + +// ClearRaidAt clears the value of the "raid_at" field. +func (uuo *UserUpdateOne) ClearRaidAt() *UserUpdateOne { + uuo.mutation.ClearRaidAt() + return uuo +} + +// SetLuck sets the "luck" field. +func (uuo *UserUpdateOne) SetLuck(i int) *UserUpdateOne { + uuo.mutation.ResetLuck() + uuo.mutation.SetLuck(i) + return uuo +} + +// SetNillableLuck sets the "luck" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableLuck(i *int) *UserUpdateOne { + if i != nil { + uuo.SetLuck(*i) + } + return uuo +} + +// AddLuck adds i to the "luck" field. +func (uuo *UserUpdateOne) AddLuck(i int) *UserUpdateOne { + uuo.mutation.AddLuck(i) + return uuo +} + +// ClearLuck clears the value of the "luck" field. +func (uuo *UserUpdateOne) ClearLuck() *UserUpdateOne { + uuo.mutation.ClearLuck() + return uuo +} + +// SetLuckAt sets the "luck_at" field. +func (uuo *UserUpdateOne) SetLuckAt(t time.Time) *UserUpdateOne { + uuo.mutation.SetLuckAt(t) + return uuo +} + +// SetNillableLuckAt sets the "luck_at" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableLuckAt(t *time.Time) *UserUpdateOne { + if t != nil { + uuo.SetLuckAt(*t) + } + return uuo +} + +// ClearLuckAt clears the value of the "luck_at" field. +func (uuo *UserUpdateOne) ClearLuckAt() *UserUpdateOne { + uuo.mutation.ClearLuckAt() + return uuo +} + +// SetLike sets the "like" field. +func (uuo *UserUpdateOne) SetLike(i int) *UserUpdateOne { + uuo.mutation.ResetLike() + uuo.mutation.SetLike(i) + return uuo +} + +// SetNillableLike sets the "like" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableLike(i *int) *UserUpdateOne { + if i != nil { + uuo.SetLike(*i) + } + return uuo +} + +// AddLike adds i to the "like" field. +func (uuo *UserUpdateOne) AddLike(i int) *UserUpdateOne { + uuo.mutation.AddLike(i) + return uuo +} + +// ClearLike clears the value of the "like" field. +func (uuo *UserUpdateOne) ClearLike() *UserUpdateOne { + uuo.mutation.ClearLike() + return uuo +} + +// SetLikeRank sets the "like_rank" field. +func (uuo *UserUpdateOne) SetLikeRank(i int) *UserUpdateOne { + uuo.mutation.ResetLikeRank() + uuo.mutation.SetLikeRank(i) + return uuo +} + +// SetNillableLikeRank sets the "like_rank" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableLikeRank(i *int) *UserUpdateOne { + if i != nil { + uuo.SetLikeRank(*i) + } + return uuo +} + +// AddLikeRank adds i to the "like_rank" field. +func (uuo *UserUpdateOne) AddLikeRank(i int) *UserUpdateOne { + uuo.mutation.AddLikeRank(i) + return uuo +} + +// ClearLikeRank clears the value of the "like_rank" field. +func (uuo *UserUpdateOne) ClearLikeRank() *UserUpdateOne { + uuo.mutation.ClearLikeRank() + return uuo +} + +// SetLikeAt sets the "like_at" field. +func (uuo *UserUpdateOne) SetLikeAt(t time.Time) *UserUpdateOne { + uuo.mutation.SetLikeAt(t) + return uuo +} + +// SetNillableLikeAt sets the "like_at" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableLikeAt(t *time.Time) *UserUpdateOne { + if t != nil { + uuo.SetLikeAt(*t) + } + return uuo +} + +// ClearLikeAt clears the value of the "like_at" field. +func (uuo *UserUpdateOne) ClearLikeAt() *UserUpdateOne { + uuo.mutation.ClearLikeAt() + return uuo +} + +// SetTen sets the "ten" field. +func (uuo *UserUpdateOne) SetTen(b bool) *UserUpdateOne { + uuo.mutation.SetTen(b) + return uuo +} + +// SetNillableTen sets the "ten" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableTen(b *bool) *UserUpdateOne { + if b != nil { + uuo.SetTen(*b) + } + return uuo +} + +// ClearTen clears the value of the "ten" field. +func (uuo *UserUpdateOne) ClearTen() *UserUpdateOne { + uuo.mutation.ClearTen() + return uuo +} + +// SetTenSu sets the "ten_su" field. +func (uuo *UserUpdateOne) SetTenSu(i int) *UserUpdateOne { + uuo.mutation.ResetTenSu() + uuo.mutation.SetTenSu(i) + return uuo +} + +// SetNillableTenSu sets the "ten_su" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableTenSu(i *int) *UserUpdateOne { + if i != nil { + uuo.SetTenSu(*i) + } + return uuo +} + +// AddTenSu adds i to the "ten_su" field. +func (uuo *UserUpdateOne) AddTenSu(i int) *UserUpdateOne { + uuo.mutation.AddTenSu(i) + return uuo +} + +// ClearTenSu clears the value of the "ten_su" field. +func (uuo *UserUpdateOne) ClearTenSu() *UserUpdateOne { + uuo.mutation.ClearTenSu() + return uuo +} + +// SetTenKai sets the "ten_kai" field. +func (uuo *UserUpdateOne) SetTenKai(i int) *UserUpdateOne { + uuo.mutation.ResetTenKai() + uuo.mutation.SetTenKai(i) + return uuo +} + +// SetNillableTenKai sets the "ten_kai" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableTenKai(i *int) *UserUpdateOne { + if i != nil { + uuo.SetTenKai(*i) + } + return uuo +} + +// AddTenKai adds i to the "ten_kai" field. +func (uuo *UserUpdateOne) AddTenKai(i int) *UserUpdateOne { + uuo.mutation.AddTenKai(i) + return uuo +} + +// ClearTenKai clears the value of the "ten_kai" field. +func (uuo *UserUpdateOne) ClearTenKai() *UserUpdateOne { + uuo.mutation.ClearTenKai() + return uuo +} + +// SetAiten sets the "aiten" field. +func (uuo *UserUpdateOne) SetAiten(i int) *UserUpdateOne { + uuo.mutation.ResetAiten() + uuo.mutation.SetAiten(i) + return uuo +} + +// SetNillableAiten sets the "aiten" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableAiten(i *int) *UserUpdateOne { + if i != nil { + uuo.SetAiten(*i) + } + return uuo +} + +// AddAiten adds i to the "aiten" field. +func (uuo *UserUpdateOne) AddAiten(i int) *UserUpdateOne { + uuo.mutation.AddAiten(i) + return uuo +} + +// ClearAiten clears the value of the "aiten" field. +func (uuo *UserUpdateOne) ClearAiten() *UserUpdateOne { + uuo.mutation.ClearAiten() + return uuo +} + +// SetTenCard sets the "ten_card" field. +func (uuo *UserUpdateOne) SetTenCard(s string) *UserUpdateOne { + uuo.mutation.SetTenCard(s) + return uuo +} + +// SetNillableTenCard sets the "ten_card" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableTenCard(s *string) *UserUpdateOne { + if s != nil { + uuo.SetTenCard(*s) + } + return uuo +} + +// ClearTenCard clears the value of the "ten_card" field. +func (uuo *UserUpdateOne) ClearTenCard() *UserUpdateOne { + uuo.mutation.ClearTenCard() + return uuo +} + +// SetTenDelete sets the "ten_delete" field. +func (uuo *UserUpdateOne) SetTenDelete(s string) *UserUpdateOne { + uuo.mutation.SetTenDelete(s) + return uuo +} + +// SetNillableTenDelete sets the "ten_delete" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableTenDelete(s *string) *UserUpdateOne { + if s != nil { + uuo.SetTenDelete(*s) + } + return uuo +} + +// ClearTenDelete clears the value of the "ten_delete" field. +func (uuo *UserUpdateOne) ClearTenDelete() *UserUpdateOne { + uuo.mutation.ClearTenDelete() + return uuo +} + +// SetTenPost sets the "ten_post" field. +func (uuo *UserUpdateOne) SetTenPost(s string) *UserUpdateOne { + uuo.mutation.SetTenPost(s) + return uuo +} + +// SetNillableTenPost sets the "ten_post" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableTenPost(s *string) *UserUpdateOne { + if s != nil { + uuo.SetTenPost(*s) + } + return uuo +} + +// ClearTenPost clears the value of the "ten_post" field. +func (uuo *UserUpdateOne) ClearTenPost() *UserUpdateOne { + uuo.mutation.ClearTenPost() + return uuo +} + +// SetTenGet sets the "ten_get" field. +func (uuo *UserUpdateOne) SetTenGet(s string) *UserUpdateOne { + uuo.mutation.SetTenGet(s) + return uuo +} + +// SetNillableTenGet sets the "ten_get" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableTenGet(s *string) *UserUpdateOne { + if s != nil { + uuo.SetTenGet(*s) + } + return uuo +} + +// ClearTenGet clears the value of the "ten_get" field. +func (uuo *UserUpdateOne) ClearTenGet() *UserUpdateOne { + uuo.mutation.ClearTenGet() + return uuo +} + +// SetTenAt sets the "ten_at" field. +func (uuo *UserUpdateOne) SetTenAt(t time.Time) *UserUpdateOne { + uuo.mutation.SetTenAt(t) + return uuo +} + +// SetNillableTenAt sets the "ten_at" field if the given value is not nil. +func (uuo *UserUpdateOne) SetNillableTenAt(t *time.Time) *UserUpdateOne { + if t != nil { + uuo.SetTenAt(*t) + } + return uuo +} + +// ClearTenAt clears the value of the "ten_at" field. +func (uuo *UserUpdateOne) ClearTenAt() *UserUpdateOne { + uuo.mutation.ClearTenAt() + return uuo +} + // SetNext sets the "next" field. func (uuo *UserUpdateOne) SetNext(s string) *UserUpdateOne { uuo.mutation.SetNext(s) @@ -538,6 +1330,114 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) if uuo.mutation.UpdatedAtCleared() { _spec.ClearField(user.FieldUpdatedAt, field.TypeTime) } + if value, ok := uuo.mutation.RaidAt(); ok { + _spec.SetField(user.FieldRaidAt, field.TypeTime, value) + } + if uuo.mutation.RaidAtCleared() { + _spec.ClearField(user.FieldRaidAt, field.TypeTime) + } + if value, ok := uuo.mutation.Luck(); ok { + _spec.SetField(user.FieldLuck, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedLuck(); ok { + _spec.AddField(user.FieldLuck, field.TypeInt, value) + } + if uuo.mutation.LuckCleared() { + _spec.ClearField(user.FieldLuck, field.TypeInt) + } + if value, ok := uuo.mutation.LuckAt(); ok { + _spec.SetField(user.FieldLuckAt, field.TypeTime, value) + } + if uuo.mutation.LuckAtCleared() { + _spec.ClearField(user.FieldLuckAt, field.TypeTime) + } + if value, ok := uuo.mutation.Like(); ok { + _spec.SetField(user.FieldLike, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedLike(); ok { + _spec.AddField(user.FieldLike, field.TypeInt, value) + } + if uuo.mutation.LikeCleared() { + _spec.ClearField(user.FieldLike, field.TypeInt) + } + if value, ok := uuo.mutation.LikeRank(); ok { + _spec.SetField(user.FieldLikeRank, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedLikeRank(); ok { + _spec.AddField(user.FieldLikeRank, field.TypeInt, value) + } + if uuo.mutation.LikeRankCleared() { + _spec.ClearField(user.FieldLikeRank, field.TypeInt) + } + if value, ok := uuo.mutation.LikeAt(); ok { + _spec.SetField(user.FieldLikeAt, field.TypeTime, value) + } + if uuo.mutation.LikeAtCleared() { + _spec.ClearField(user.FieldLikeAt, field.TypeTime) + } + if value, ok := uuo.mutation.Ten(); ok { + _spec.SetField(user.FieldTen, field.TypeBool, value) + } + if uuo.mutation.TenCleared() { + _spec.ClearField(user.FieldTen, field.TypeBool) + } + if value, ok := uuo.mutation.TenSu(); ok { + _spec.SetField(user.FieldTenSu, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedTenSu(); ok { + _spec.AddField(user.FieldTenSu, field.TypeInt, value) + } + if uuo.mutation.TenSuCleared() { + _spec.ClearField(user.FieldTenSu, field.TypeInt) + } + if value, ok := uuo.mutation.TenKai(); ok { + _spec.SetField(user.FieldTenKai, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedTenKai(); ok { + _spec.AddField(user.FieldTenKai, field.TypeInt, value) + } + if uuo.mutation.TenKaiCleared() { + _spec.ClearField(user.FieldTenKai, field.TypeInt) + } + if value, ok := uuo.mutation.Aiten(); ok { + _spec.SetField(user.FieldAiten, field.TypeInt, value) + } + if value, ok := uuo.mutation.AddedAiten(); ok { + _spec.AddField(user.FieldAiten, field.TypeInt, value) + } + if uuo.mutation.AitenCleared() { + _spec.ClearField(user.FieldAiten, field.TypeInt) + } + if value, ok := uuo.mutation.TenCard(); ok { + _spec.SetField(user.FieldTenCard, field.TypeString, value) + } + if uuo.mutation.TenCardCleared() { + _spec.ClearField(user.FieldTenCard, field.TypeString) + } + if value, ok := uuo.mutation.TenDelete(); ok { + _spec.SetField(user.FieldTenDelete, field.TypeString, value) + } + if uuo.mutation.TenDeleteCleared() { + _spec.ClearField(user.FieldTenDelete, field.TypeString) + } + if value, ok := uuo.mutation.TenPost(); ok { + _spec.SetField(user.FieldTenPost, field.TypeString, value) + } + if uuo.mutation.TenPostCleared() { + _spec.ClearField(user.FieldTenPost, field.TypeString) + } + if value, ok := uuo.mutation.TenGet(); ok { + _spec.SetField(user.FieldTenGet, field.TypeString, value) + } + if uuo.mutation.TenGetCleared() { + _spec.ClearField(user.FieldTenGet, field.TypeString) + } + if value, ok := uuo.mutation.TenAt(); ok { + _spec.SetField(user.FieldTenAt, field.TypeTime, value) + } + if uuo.mutation.TenAtCleared() { + _spec.ClearField(user.FieldTenAt, field.TypeTime) + } if value, ok := uuo.mutation.Next(); ok { _spec.SetField(user.FieldNext, field.TypeString, value) } diff --git a/tmp/card_add.zsh b/tmp/card_add.zsh index 932adaf..faa96f8 100755 --- a/tmp/card_add.zsh +++ b/tmp/card_add.zsh @@ -1,5 +1,5 @@ #!/bin/zsh -echo id card cp +echo username card cp read host=https://api.syui.ai pass=`cat ~/.config/atr/api_card.json|jq -r .password` @@ -13,7 +13,7 @@ if [ -z "$3" ];then exit fi -id=$1 +id=`curl -sL "$host/users?itemsPerPage=2000"|jq ".[]|select(.username == \"$1\")"|jq -r .id` card=$2 cp=$3 s="normal" diff --git a/tmp/card_limit_all.zsh b/tmp/card_limit_all.zsh index 781edb9..06c0641 100755 --- a/tmp/card_limit_all.zsh +++ b/tmp/card_limit_all.zsh @@ -9,6 +9,8 @@ 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"` @@ -16,8 +18,12 @@ n=`echo $data|jq length` n=$((n - 1)) if [ -n "$1" ];then - id=$1 - curl -X PATCH -H "Content-Type: application/json" -d "{\"next\":\"$nd\", \"updated_at\":\"$updated_at_n\",\"token\":\"$token\"}" -s $host/users/$id + 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\", \"updated_at\":\"$updated_at_n\", \"raid_at\":\"$raid_at_n\", \"token\":\"$token\", \"luck_at\": \"$now_at\", \"luck\": 7, \"like\":0}" -s $host/users/$id + else + curl -X PATCH -H "Content-Type: application/json" -d "{\"next\":\"$nd\", \"updated_at\":\"$updated_at_n\", \"raid_at\":\"$raid_at_n\", \"ten_su\": 0, \"luck_at\": \"$now_at\", \"ten\":false,\"ten_at\": \"$updated_at_n\",\"token\": \"$token\",\"ten_kai\" : 0}" -s $host/users/$id + fi exit fi @@ -26,5 +32,9 @@ do name=`echo $data|jq ".[$i]"|jq -r .username` id=`echo $data|jq ".[$i]"|jq -r .id` echo "{\"updated_at\":\"$updated_at_n\"} -s $host/users/$id" - curl -X PATCH -H "Content-Type: application/json" -d "{\"next\":\"$nd\", \"updated_at\":\"$updated_at_n\",\"token\":\"$token\"}" -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 + else + 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\", \"ten_at\": \"$updated_at_n\"}" -s $host/users/$id + fi done diff --git a/tmp/ogent/oas_parameters_gen.go b/tmp/ogent/oas_parameters_gen.go index 127c6f7..c9ce70c 100644 --- a/tmp/ogent/oas_parameters_gen.go +++ b/tmp/ogent/oas_parameters_gen.go @@ -459,7 +459,7 @@ func decodeListCardParams(args [0]string, r *http.Request) (params ListCardParam MinSet: true, Min: 1, MaxSet: true, - Max: 3500, + Max: 4000, MinExclusive: false, MaxExclusive: false, MultipleOfSet: false, @@ -624,7 +624,7 @@ func decodeListGroupParams(args [0]string, r *http.Request) (params ListGroupPar MinSet: true, Min: 1, MaxSet: true, - Max: 3500, + Max: 4000, MinExclusive: false, MaxExclusive: false, MultipleOfSet: false, @@ -956,7 +956,7 @@ func decodeListUserParams(args [0]string, r *http.Request) (params ListUserParam MinSet: true, Min: 1, MaxSet: true, - Max: 3500, + Max: 4000, MinExclusive: false, MaxExclusive: false, MultipleOfSet: false, diff --git a/tmp/ogent/ogent.go b/tmp/ogent/ogent.go index 5b3edf3..779818f 100644 --- a/tmp/ogent/ogent.go +++ b/tmp/ogent/ogent.go @@ -15,10 +15,10 @@ import ( "os" ) +// origin-config var password = os.Getenv("PASS") var token = os.Getenv("TOKEN") -var zero = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" // OgentHandler implements the ogen generated Handler interface and uses Ent as data layer. type OgentHandler struct { client *ent.Client @@ -42,6 +42,9 @@ func (h *OgentHandler) CreateCard(ctx context.Context, req *CreateCardReq) (Crea if v, ok := req.Card.Get(); ok { b.SetCard(v) } + if v, ok := req.Skill.Get(); ok { + b.SetSkill(v) + } if v, ok := req.Status.Get(); ok { b.SetStatus(v) } @@ -54,11 +57,9 @@ func (h *OgentHandler) CreateCard(ctx context.Context, req *CreateCardReq) (Crea if v, ok := req.CreatedAt.Get(); ok { b.SetCreatedAt(v) } - if v, ok := req.Skill.Get(); ok { - b.SetSkill(v) - } // Add all edges. - + //b.SetOwnerID(req.Owner) + // origin-config if req.Password == password { b.SetOwnerID(req.Owner) } else { @@ -123,12 +124,19 @@ func (h *OgentHandler) ReadCard(ctx context.Context, params ReadCardParams) (Rea // UpdateCard handles PATCH /cards/{id} requests. func (h *OgentHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, params UpdateCardParams) (UpdateCardRes, error) { - b := h.client.Card.UpdateOneID(0) - // Add all fields. - // Add all edges. - if v, ok := req.Owner.Get(); ok { - b.SetOwnerID(v) - } + b := h.client.Card.UpdateOneID(params.ID) + + + // Add all fields. + if v, ok := req.Skill.Get(); ok { + b.SetSkill(v) + } + // Add all edges. + if v, ok := req.Owner.Get(); ok { + b.SetOwnerID(v) + } + + // Persist to storage. e, err := b.Save(ctx) if err != nil { @@ -163,7 +171,6 @@ func (h *OgentHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, param // DeleteCard handles DELETE /cards/{id} requests. func (h *OgentHandler) DeleteCard(ctx context.Context, params DeleteCardParams) (DeleteCardRes, error) { err := h.client.Card.DeleteOneID(0).Exec(ctx) - //err := h.client.Card.DeleteOneID(params.ID).Exec(ctx) if err != nil { switch { case ent.IsNotFound(err): @@ -254,7 +261,7 @@ func (h *OgentHandler) ReadCardOwner(ctx context.Context, params ReadCardOwnerPa func (h *OgentHandler) CreateGroup(ctx context.Context, req *CreateGroupReq) (CreateGroupRes, error) { b := h.client.Group.Create() // Add all fields. - b.SetName(req.Name) + b.SetName("") b.SetPassword(req.Password) // Add all edges. b.AddUserIDs(req.Users...) @@ -359,7 +366,7 @@ func (h *OgentHandler) UpdateGroup(ctx context.Context, req *UpdateGroupReq, par // DeleteGroup handles DELETE /groups/{id} requests. func (h *OgentHandler) DeleteGroup(ctx context.Context, params DeleteGroupParams) (DeleteGroupRes, error) { - err := h.client.Group.DeleteOneID(params.ID).Exec(ctx) + err := h.client.Group.DeleteOneID(0).Exec(ctx) if err != nil { switch { case ent.IsNotFound(err): @@ -459,7 +466,10 @@ func (h *OgentHandler) ListGroupUsers(ctx context.Context, params ListGroupUsers // CreateUser handles POST /users requests. func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (CreateUserRes, error) { b := h.client.User.Create() + // Add all fields. + //b.SetUsername(req.Username) + //origin-config if req.Password == password { b.SetUsername(req.Username) } else { @@ -467,15 +477,67 @@ func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (Crea } b.SetPassword(req.Password) + if v, ok := req.Did.Get(); ok { b.SetDid(v) } + if v, ok := req.Delete.Get(); ok { + b.SetDelete(v) + } + if v, ok := req.Token.Get(); ok { + b.SetToken(v) + } if v, ok := req.CreatedAt.Get(); ok { b.SetCreatedAt(v) } if v, ok := req.UpdatedAt.Get(); ok { b.SetUpdatedAt(v) } + if v, ok := req.RaidAt.Get(); ok { + b.SetRaidAt(v) + } + if v, ok := req.Luck.Get(); ok { + b.SetLuck(v) + } + if v, ok := req.Aiten.Get(); ok { + b.SetAiten(v) + } + if v, ok := req.LuckAt.Get(); ok { + b.SetLuckAt(v) + } + if v, ok := req.Like.Get(); ok { + b.SetLike(v) + } + if v, ok := req.LikeRank.Get(); ok { + b.SetLikeRank(v) + } + if v, ok := req.LikeAt.Get(); ok { + b.SetLikeAt(v) + } + if v, ok := req.Ten.Get(); ok { + b.SetTen(v) + } + if v, ok := req.TenSu.Get(); ok { + b.SetTenSu(v) + } + if v, ok := req.TenKai.Get(); ok { + b.SetTenKai(v) + } + if v, ok := req.TenCard.Get(); ok { + b.SetTenCard(v) + } + if v, ok := req.TenDelete.Get(); ok { + b.SetTenDelete(v) + } + if v, ok := req.TenPost.Get(); ok { + b.SetTenPost(v) + } + if v, ok := req.TenGet.Get(); ok { + b.SetTenGet(v) + } + if v, ok := req.TenAt.Get(); ok { + b.SetTenAt(v) + } if v, ok := req.Next.Get(); ok { b.SetNext(v) } @@ -483,7 +545,6 @@ func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (Crea b.AddCardIDs(req.Card...) // Persist to storage. e, err := b.Save(ctx) - if err != nil { switch { case ent.IsNotSingular(err): @@ -546,16 +607,62 @@ func (h *OgentHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, param if v, ok := req.Token.Get(); ok { if v == token { b.SetToken(v) - // Add all fields. + if v, ok := req.Did.Get(); ok { b.SetDid(v) } if v, ok := req.Delete.Get(); ok { b.SetDelete(v) } + if v, ok := req.UpdatedAt.Get(); ok { b.SetUpdatedAt(v) } + if v, ok := req.RaidAt.Get(); ok { + b.SetRaidAt(v) + } + if v, ok := req.Aiten.Get(); ok { + b.SetAiten(v) + } + if v, ok := req.Luck.Get(); ok { + b.SetLuck(v) + } + if v, ok := req.LuckAt.Get(); ok { + b.SetLuckAt(v) + } + if v, ok := req.Like.Get(); ok { + b.SetLike(v) + } + if v, ok := req.LikeRank.Get(); ok { + b.SetLikeRank(v) + } + if v, ok := req.LikeAt.Get(); ok { + b.SetLikeAt(v) + } + if v, ok := req.Ten.Get(); ok { + b.SetTen(v) + } + if v, ok := req.TenSu.Get(); ok { + b.SetTenSu(v) + } + if v, ok := req.TenKai.Get(); ok { + b.SetTenKai(v) + } + if v, ok := req.TenCard.Get(); ok { + b.SetTenCard(v) + } + if v, ok := req.TenDelete.Get(); ok { + b.SetTenDelete(v) + } + if v, ok := req.TenPost.Get(); ok { + b.SetTenPost(v) + } + if v, ok := req.TenGet.Get(); ok { + b.SetTenGet(v) + } + if v, ok := req.TenAt.Get(); ok { + b.SetTenAt(v) + } if v, ok := req.Next.Get(); ok { b.SetNext(v) } @@ -563,11 +670,11 @@ func (h *OgentHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, param if req.Card != nil { b.ClearCard().AddCardIDs(req.Card...) } - // Persist to storage. } } - e, err := b.Save(ctx) + // Persist to storage. + e, err := b.Save(ctx) if err != nil { switch { case ent.IsNotFound(err): diff --git a/tmp/test.zsh b/tmp/test.zsh new file mode 100755 index 0000000..d067c48 --- /dev/null +++ b/tmp/test.zsh @@ -0,0 +1,75 @@ +#!/bin/zsh + +case $OSTYPE in + darwin*) + alias date="/opt/homebrew/bin/gdate" + ;; +esac +u=ai +s=normal +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` +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"` +card=0 +cp=0 +body="next[y]" +id=`curl -sL "$host/users?itemsPerPage=2000"|jq ".[]|select(.username == \"$u\")"|jq -r .id` +echo $id + +#echo no token +#curl -X PATCH -H "Content-Type: application/json" -d "{\"next\":\"$nd\", \"updated_at\":\"$updated_at_n\", \"raid_at\":\"$raid_at_n\", \"ten_su\": 1, \"luck_at\": \"$now_at\", \"ten_at\": \"$updated_at_n\"}" -s $host/users/$id +#echo $body +#read +# +#echo yes token +#echo $token +#curl -X PATCH -H "Content-Type: application/json" -d "{\"next\":\"$nd\", \"updated_at\":\"$updated_at_n\", \"raid_at\":\"$raid_at_n\", \"ten_su\": 1, \"luck_at\": \"$now_at\", \"ten_at\": \"$updated_at_n\",\"token\": \"$token\"}" -s $host/users/$id +#echo $body +#read +# +#echo account delete id no token +#curl -X PATCH -H "Content-Type: application/json" -d "{\"delete\":true}" -s $host/users/381 +#echo $body +#read +# +#echo account delete id token +#curl -X PATCH -H "Content-Type: application/json" -d "{\"delete\":false,\"token\":\"$token\"}" -s $host/users/381 +#echo $body +#read +# +#echo add card no pass +#curl -X POST -H "Content-Type: application/json" -d "{\"owner\":$id,\"card\":$card,\"status\":\"$s\",\"cp\":$cp}" -sL $host/cards +#echo $body +#read +# +#echo add card no pass +#echo $id +#curl -X POST -H "Content-Type: application/json" -d "{\"owner\":$id,\"card\":$card,\"status\":\"$s\",\"cp\":$cp,\"password\":\"$pass\"}" -sL $host/cards +#echo $body +#read +# +#echo add user +#curl -X POST -H "Content-Type: application/json" -d "{\"username\":\"test\",\"did\":\"t\"}" -s "$host/users" +#echo $body +#read +# +#echo add user pass +#curl -X POST -H "Content-Type: application/json" -d "{\"username\":\"test\",\"did\":\"t\",\"password\":\"$pass\"}" -s "$host/users" +#echo $body +#read + +#echo card draw no pass +#curl -X POST -H "Content-Type: application/json" -d "{\"owner\":$id}" -s $host/cards +#echo $body +#read +# +#echo card draw ok pass +#curl -X POST -H "Content-Type: application/json" -d "{\"owner\":$id,\"password\":\"$pass\"}" -s $host/cards +#echo $body +#read