fix ue game lv

ent/mutation.go

@@ -5114,6 +5114,9 @@ type UeMutation struct {
 	location_n    *int
 	addlocation_n *int
 	author        *string
+	game_lv       *string
+	game_exp      *string
+	game_id       *string
 	created_at    *time.Time
 	clearedFields map[string]struct{}
 	owner         *int
@@ -6321,6 +6324,153 @@ func (m *UeMutation) ResetAuthor() {
 	delete(m.clearedFields, ue.FieldAuthor)
 }
 
+// SetGameLv sets the "game_lv" field.
+func (m *UeMutation) SetGameLv(s string) {
+	m.game_lv = &s
+}
+
+// GameLv returns the value of the "game_lv" field in the mutation.
+func (m *UeMutation) GameLv() (r string, exists bool) {
+	v := m.game_lv
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldGameLv returns the old "game_lv" field's value of the Ue entity.
+// If the Ue 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 *UeMutation) OldGameLv(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldGameLv is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldGameLv requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldGameLv: %w", err)
+	}
+	return oldValue.GameLv, nil
+}
+
+// ClearGameLv clears the value of the "game_lv" field.
+func (m *UeMutation) ClearGameLv() {
+	m.game_lv = nil
+	m.clearedFields[ue.FieldGameLv] = struct{}{}
+}
+
+// GameLvCleared returns if the "game_lv" field was cleared in this mutation.
+func (m *UeMutation) GameLvCleared() bool {
+	_, ok := m.clearedFields[ue.FieldGameLv]
+	return ok
+}
+
+// ResetGameLv resets all changes to the "game_lv" field.
+func (m *UeMutation) ResetGameLv() {
+	m.game_lv = nil
+	delete(m.clearedFields, ue.FieldGameLv)
+}
+
+// SetGameExp sets the "game_exp" field.
+func (m *UeMutation) SetGameExp(s string) {
+	m.game_exp = &s
+}
+
+// GameExp returns the value of the "game_exp" field in the mutation.
+func (m *UeMutation) GameExp() (r string, exists bool) {
+	v := m.game_exp
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldGameExp returns the old "game_exp" field's value of the Ue entity.
+// If the Ue 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 *UeMutation) OldGameExp(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldGameExp is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldGameExp requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldGameExp: %w", err)
+	}
+	return oldValue.GameExp, nil
+}
+
+// ClearGameExp clears the value of the "game_exp" field.
+func (m *UeMutation) ClearGameExp() {
+	m.game_exp = nil
+	m.clearedFields[ue.FieldGameExp] = struct{}{}
+}
+
+// GameExpCleared returns if the "game_exp" field was cleared in this mutation.
+func (m *UeMutation) GameExpCleared() bool {
+	_, ok := m.clearedFields[ue.FieldGameExp]
+	return ok
+}
+
+// ResetGameExp resets all changes to the "game_exp" field.
+func (m *UeMutation) ResetGameExp() {
+	m.game_exp = nil
+	delete(m.clearedFields, ue.FieldGameExp)
+}
+
+// SetGameID sets the "game_id" field.
+func (m *UeMutation) SetGameID(s string) {
+	m.game_id = &s
+}
+
+// GameID returns the value of the "game_id" field in the mutation.
+func (m *UeMutation) GameID() (r string, exists bool) {
+	v := m.game_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldGameID returns the old "game_id" field's value of the Ue entity.
+// If the Ue 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 *UeMutation) OldGameID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldGameID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldGameID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldGameID: %w", err)
+	}
+	return oldValue.GameID, nil
+}
+
+// ClearGameID clears the value of the "game_id" field.
+func (m *UeMutation) ClearGameID() {
+	m.game_id = nil
+	m.clearedFields[ue.FieldGameID] = struct{}{}
+}
+
+// GameIDCleared returns if the "game_id" field was cleared in this mutation.
+func (m *UeMutation) GameIDCleared() bool {
+	_, ok := m.clearedFields[ue.FieldGameID]
+	return ok
+}
+
+// ResetGameID resets all changes to the "game_id" field.
+func (m *UeMutation) ResetGameID() {
+	m.game_id = nil
+	delete(m.clearedFields, ue.FieldGameID)
+}
+
 // SetCreatedAt sets the "created_at" field.
 func (m *UeMutation) SetCreatedAt(t time.Time) {
 	m.created_at = &t
@@ -6443,7 +6593,7 @@ func (m *UeMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *UeMutation) Fields() []string {
-	fields := make([]string, 0, 19)
+	fields := make([]string, 0, 22)
 	if m._limit != nil {
 		fields = append(fields, ue.FieldLimit)
 	}
@@ -6498,6 +6648,15 @@ func (m *UeMutation) Fields() []string {
 	if m.author != nil {
 		fields = append(fields, ue.FieldAuthor)
 	}
+	if m.game_lv != nil {
+		fields = append(fields, ue.FieldGameLv)
+	}
+	if m.game_exp != nil {
+		fields = append(fields, ue.FieldGameExp)
+	}
+	if m.game_id != nil {
+		fields = append(fields, ue.FieldGameID)
+	}
 	if m.created_at != nil {
 		fields = append(fields, ue.FieldCreatedAt)
 	}
@@ -6545,6 +6704,12 @@ func (m *UeMutation) Field(name string) (ent.Value, bool) {
 		return m.LocationN()
 	case ue.FieldAuthor:
 		return m.Author()
+	case ue.FieldGameLv:
+		return m.GameLv()
+	case ue.FieldGameExp:
+		return m.GameExp()
+	case ue.FieldGameID:
+		return m.GameID()
 	case ue.FieldCreatedAt:
 		return m.CreatedAt()
 	}
@@ -6592,6 +6757,12 @@ func (m *UeMutation) OldField(ctx context.Context, name string) (ent.Value, erro
 		return m.OldLocationN(ctx)
 	case ue.FieldAuthor:
 		return m.OldAuthor(ctx)
+	case ue.FieldGameLv:
+		return m.OldGameLv(ctx)
+	case ue.FieldGameExp:
+		return m.OldGameExp(ctx)
+	case ue.FieldGameID:
+		return m.OldGameID(ctx)
 	case ue.FieldCreatedAt:
 		return m.OldCreatedAt(ctx)
 	}
@@ -6729,6 +6900,27 @@ func (m *UeMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetAuthor(v)
 		return nil
+	case ue.FieldGameLv:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetGameLv(v)
+		return nil
+	case ue.FieldGameExp:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetGameExp(v)
+		return nil
+	case ue.FieldGameID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetGameID(v)
+		return nil
 	case ue.FieldCreatedAt:
 		v, ok := value.(time.Time)
 		if !ok {
@@ -6952,6 +7144,15 @@ func (m *UeMutation) ClearedFields() []string {
 	if m.FieldCleared(ue.FieldAuthor) {
 		fields = append(fields, ue.FieldAuthor)
 	}
+	if m.FieldCleared(ue.FieldGameLv) {
+		fields = append(fields, ue.FieldGameLv)
+	}
+	if m.FieldCleared(ue.FieldGameExp) {
+		fields = append(fields, ue.FieldGameExp)
+	}
+	if m.FieldCleared(ue.FieldGameID) {
+		fields = append(fields, ue.FieldGameID)
+	}
 	if m.FieldCleared(ue.FieldCreatedAt) {
 		fields = append(fields, ue.FieldCreatedAt)
 	}
@@ -7020,6 +7221,15 @@ func (m *UeMutation) ClearField(name string) error {
 	case ue.FieldAuthor:
 		m.ClearAuthor()
 		return nil
+	case ue.FieldGameLv:
+		m.ClearGameLv()
+		return nil
+	case ue.FieldGameExp:
+		m.ClearGameExp()
+		return nil
+	case ue.FieldGameID:
+		m.ClearGameID()
+		return nil
 	case ue.FieldCreatedAt:
 		m.ClearCreatedAt()
 		return nil
@@ -7085,6 +7295,15 @@ func (m *UeMutation) ResetField(name string) error {
 	case ue.FieldAuthor:
 		m.ResetAuthor()
 		return nil
+	case ue.FieldGameLv:
+		m.ResetGameLv()
+		return nil
+	case ue.FieldGameExp:
+		m.ResetGameExp()
+		return nil
+	case ue.FieldGameID:
+		m.ResetGameID()
+		return nil
 	case ue.FieldCreatedAt:
 		m.ResetCreatedAt()
 		return nil
@@ -7234,6 +7453,8 @@ type UserMutation struct {
 	game_account        *bool
 	game_lv             *int
 	addgame_lv          *int
+	game_exp            *int
+	addgame_exp         *int
 	coin                *int
 	addcoin             *int
 	coin_open           *bool
@@ -9946,6 +10167,76 @@ func (m *UserMutation) ResetGameLv() {
 	delete(m.clearedFields, user.FieldGameLv)
 }
 
+// SetGameExp sets the "game_exp" field.
+func (m *UserMutation) SetGameExp(i int) {
+	m.game_exp = &i
+	m.addgame_exp = nil
+}
+
+// GameExp returns the value of the "game_exp" field in the mutation.
+func (m *UserMutation) GameExp() (r int, exists bool) {
+	v := m.game_exp
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldGameExp returns the old "game_exp" 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) OldGameExp(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldGameExp is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldGameExp requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldGameExp: %w", err)
+	}
+	return oldValue.GameExp, nil
+}
+
+// AddGameExp adds i to the "game_exp" field.
+func (m *UserMutation) AddGameExp(i int) {
+	if m.addgame_exp != nil {
+		*m.addgame_exp += i
+	} else {
+		m.addgame_exp = &i
+	}
+}
+
+// AddedGameExp returns the value that was added to the "game_exp" field in this mutation.
+func (m *UserMutation) AddedGameExp() (r int, exists bool) {
+	v := m.addgame_exp
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ClearGameExp clears the value of the "game_exp" field.
+func (m *UserMutation) ClearGameExp() {
+	m.game_exp = nil
+	m.addgame_exp = nil
+	m.clearedFields[user.FieldGameExp] = struct{}{}
+}
+
+// GameExpCleared returns if the "game_exp" field was cleared in this mutation.
+func (m *UserMutation) GameExpCleared() bool {
+	_, ok := m.clearedFields[user.FieldGameExp]
+	return ok
+}
+
+// ResetGameExp resets all changes to the "game_exp" field.
+func (m *UserMutation) ResetGameExp() {
+	m.game_exp = nil
+	m.addgame_exp = nil
+	delete(m.clearedFields, user.FieldGameExp)
+}
+
 // SetCoin sets the "coin" field.
 func (m *UserMutation) SetCoin(i int) {
 	m.coin = &i
@@ -10364,7 +10655,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, 50)
+	fields := make([]string, 0, 51)
 	if m.username != nil {
 		fields = append(fields, user.FieldUsername)
 	}
@@ -10506,6 +10797,9 @@ func (m *UserMutation) Fields() []string {
 	if m.game_lv != nil {
 		fields = append(fields, user.FieldGameLv)
 	}
+	if m.game_exp != nil {
+		fields = append(fields, user.FieldGameExp)
+	}
 	if m.coin != nil {
 		fields = append(fields, user.FieldCoin)
 	}
@@ -10617,6 +10911,8 @@ func (m *UserMutation) Field(name string) (ent.Value, bool) {
 		return m.GameAccount()
 	case user.FieldGameLv:
 		return m.GameLv()
+	case user.FieldGameExp:
+		return m.GameExp()
 	case user.FieldCoin:
 		return m.Coin()
 	case user.FieldCoinOpen:
@@ -10726,6 +11022,8 @@ func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, er
 		return m.OldGameAccount(ctx)
 	case user.FieldGameLv:
 		return m.OldGameLv(ctx)
+	case user.FieldGameExp:
+		return m.OldGameExp(ctx)
 	case user.FieldCoin:
 		return m.OldCoin(ctx)
 	case user.FieldCoinOpen:
@@ -11070,6 +11368,13 @@ func (m *UserMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetGameLv(v)
 		return nil
+	case user.FieldGameExp:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetGameExp(v)
+		return nil
 	case user.FieldCoin:
 		v, ok := value.(int)
 		if !ok {
@@ -11144,6 +11449,9 @@ func (m *UserMutation) AddedFields() []string {
 	if m.addgame_lv != nil {
 		fields = append(fields, user.FieldGameLv)
 	}
+	if m.addgame_exp != nil {
+		fields = append(fields, user.FieldGameExp)
+	}
 	if m.addcoin != nil {
 		fields = append(fields, user.FieldCoin)
 	}
@@ -11185,6 +11493,8 @@ func (m *UserMutation) AddedField(name string) (ent.Value, bool) {
 		return m.AddedModelCriticalD()
 	case user.FieldGameLv:
 		return m.AddedGameLv()
+	case user.FieldGameExp:
+		return m.AddedGameExp()
 	case user.FieldCoin:
 		return m.AddedCoin()
 	}
@@ -11301,6 +11611,13 @@ func (m *UserMutation) AddField(name string, value ent.Value) error {
 		}
 		m.AddGameLv(v)
 		return nil
+	case user.FieldGameExp:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddGameExp(v)
+		return nil
 	case user.FieldCoin:
 		v, ok := value.(int)
 		if !ok {
@@ -11451,6 +11768,9 @@ func (m *UserMutation) ClearedFields() []string {
 	if m.FieldCleared(user.FieldGameLv) {
 		fields = append(fields, user.FieldGameLv)
 	}
+	if m.FieldCleared(user.FieldGameExp) {
+		fields = append(fields, user.FieldGameExp)
+	}
 	if m.FieldCleared(user.FieldCoin) {
 		fields = append(fields, user.FieldCoin)
 	}
@@ -11609,6 +11929,9 @@ func (m *UserMutation) ClearField(name string) error {
 	case user.FieldGameLv:
 		m.ClearGameLv()
 		return nil
+	case user.FieldGameExp:
+		m.ClearGameExp()
+		return nil
 	case user.FieldCoin:
 		m.ClearCoin()
 		return nil
@@ -11767,6 +12090,9 @@ func (m *UserMutation) ResetField(name string) error {
 	case user.FieldGameLv:
 		m.ResetGameLv()
 		return nil
+	case user.FieldGameExp:
+		m.ResetGameExp()
+		return nil
 	case user.FieldCoin:
 		m.ResetCoin()
 		return nil