added gameban as separate thing

ent/migrate/schema.go

@@ -37,6 +37,8 @@ var (
 		{Name: "vanity_url_real", Type: field.TypeString, Nullable: true},
 		{Name: "vac_date", Type: field.TypeTime, Nullable: true},
 		{Name: "vac_count", Type: field.TypeInt, Nullable: true},
+		{Name: "game_ban_date", Type: field.TypeTime, Nullable: true},
+		{Name: "game_ban_count", Type: field.TypeInt, Nullable: true},
 		{Name: "steam_updated", Type: field.TypeTime},
 		{Name: "sharecode_updated", Type: field.TypeTime, Nullable: true},
 		{Name: "auth_code", Type: field.TypeString, Nullable: true},

ent/mutation.go

@@ -1215,6 +1215,9 @@ type PlayerMutation struct {
 	vac_date              *time.Time
 	vac_count             *int
 	addvac_count          *int
+	game_ban_date         *time.Time
+	game_ban_count        *int
+	addgame_ban_count     *int
 	steam_updated         *time.Time
 	sharecode_updated     *time.Time
 	auth_code             *string
@@ -1632,6 +1635,125 @@ func (m *PlayerMutation) ResetVacCount() {
 	delete(m.clearedFields, player.FieldVacCount)
 }
 
+// SetGameBanDate sets the "game_ban_date" field.
+func (m *PlayerMutation) SetGameBanDate(t time.Time) {
+	m.game_ban_date = &t
+}
+
+// GameBanDate returns the value of the "game_ban_date" field in the mutation.
+func (m *PlayerMutation) GameBanDate() (r time.Time, exists bool) {
+	v := m.game_ban_date
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldGameBanDate returns the old "game_ban_date" field's value of the Player entity.
+// If the Player 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 *PlayerMutation) OldGameBanDate(ctx context.Context) (v time.Time, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, fmt.Errorf("OldGameBanDate is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, fmt.Errorf("OldGameBanDate requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldGameBanDate: %w", err)
+	}
+	return oldValue.GameBanDate, nil
+}
+
+// ClearGameBanDate clears the value of the "game_ban_date" field.
+func (m *PlayerMutation) ClearGameBanDate() {
+	m.game_ban_date = nil
+	m.clearedFields[player.FieldGameBanDate] = struct{}{}
+}
+
+// GameBanDateCleared returns if the "game_ban_date" field was cleared in this mutation.
+func (m *PlayerMutation) GameBanDateCleared() bool {
+	_, ok := m.clearedFields[player.FieldGameBanDate]
+	return ok
+}
+
+// ResetGameBanDate resets all changes to the "game_ban_date" field.
+func (m *PlayerMutation) ResetGameBanDate() {
+	m.game_ban_date = nil
+	delete(m.clearedFields, player.FieldGameBanDate)
+}
+
+// SetGameBanCount sets the "game_ban_count" field.
+func (m *PlayerMutation) SetGameBanCount(i int) {
+	m.game_ban_count = &i
+	m.addgame_ban_count = nil
+}
+
+// GameBanCount returns the value of the "game_ban_count" field in the mutation.
+func (m *PlayerMutation) GameBanCount() (r int, exists bool) {
+	v := m.game_ban_count
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldGameBanCount returns the old "game_ban_count" field's value of the Player entity.
+// If the Player 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 *PlayerMutation) OldGameBanCount(ctx context.Context) (v int, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, fmt.Errorf("OldGameBanCount is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, fmt.Errorf("OldGameBanCount requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldGameBanCount: %w", err)
+	}
+	return oldValue.GameBanCount, nil
+}
+
+// AddGameBanCount adds i to the "game_ban_count" field.
+func (m *PlayerMutation) AddGameBanCount(i int) {
+	if m.addgame_ban_count != nil {
+		*m.addgame_ban_count += i
+	} else {
+		m.addgame_ban_count = &i
+	}
+}
+
+// AddedGameBanCount returns the value that was added to the "game_ban_count" field in this mutation.
+func (m *PlayerMutation) AddedGameBanCount() (r int, exists bool) {
+	v := m.addgame_ban_count
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ClearGameBanCount clears the value of the "game_ban_count" field.
+func (m *PlayerMutation) ClearGameBanCount() {
+	m.game_ban_count = nil
+	m.addgame_ban_count = nil
+	m.clearedFields[player.FieldGameBanCount] = struct{}{}
+}
+
+// GameBanCountCleared returns if the "game_ban_count" field was cleared in this mutation.
+func (m *PlayerMutation) GameBanCountCleared() bool {
+	_, ok := m.clearedFields[player.FieldGameBanCount]
+	return ok
+}
+
+// ResetGameBanCount resets all changes to the "game_ban_count" field.
+func (m *PlayerMutation) ResetGameBanCount() {
+	m.game_ban_count = nil
+	m.addgame_ban_count = nil
+	delete(m.clearedFields, player.FieldGameBanCount)
+}
+
 // SetSteamUpdated sets the "steam_updated" field.
 func (m *PlayerMutation) SetSteamUpdated(t time.Time) {
 	m.steam_updated = &t
@@ -1991,7 +2113,7 @@ func (m *PlayerMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *PlayerMutation) Fields() []string {
-	fields := make([]string, 0, 11)
+	fields := make([]string, 0, 13)
 	if m.name != nil {
 		fields = append(fields, player.FieldName)
 	}
@@ -2010,6 +2132,12 @@ func (m *PlayerMutation) Fields() []string {
 	if m.vac_count != nil {
 		fields = append(fields, player.FieldVacCount)
 	}
+	if m.game_ban_date != nil {
+		fields = append(fields, player.FieldGameBanDate)
+	}
+	if m.game_ban_count != nil {
+		fields = append(fields, player.FieldGameBanCount)
+	}
 	if m.steam_updated != nil {
 		fields = append(fields, player.FieldSteamUpdated)
 	}
@@ -2045,6 +2173,10 @@ func (m *PlayerMutation) Field(name string) (ent.Value, bool) {
 		return m.VacDate()
 	case player.FieldVacCount:
 		return m.VacCount()
+	case player.FieldGameBanDate:
+		return m.GameBanDate()
+	case player.FieldGameBanCount:
+		return m.GameBanCount()
 	case player.FieldSteamUpdated:
 		return m.SteamUpdated()
 	case player.FieldSharecodeUpdated:
@@ -2076,6 +2208,10 @@ func (m *PlayerMutation) OldField(ctx context.Context, name string) (ent.Value,
 		return m.OldVacDate(ctx)
 	case player.FieldVacCount:
 		return m.OldVacCount(ctx)
+	case player.FieldGameBanDate:
+		return m.OldGameBanDate(ctx)
+	case player.FieldGameBanCount:
+		return m.OldGameBanCount(ctx)
 	case player.FieldSteamUpdated:
 		return m.OldSteamUpdated(ctx)
 	case player.FieldSharecodeUpdated:
@@ -2137,6 +2273,20 @@ func (m *PlayerMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetVacCount(v)
 		return nil
+	case player.FieldGameBanDate:
+		v, ok := value.(time.Time)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetGameBanDate(v)
+		return nil
+	case player.FieldGameBanCount:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetGameBanCount(v)
+		return nil
 	case player.FieldSteamUpdated:
 		v, ok := value.(time.Time)
 		if !ok {
@@ -2183,6 +2333,9 @@ func (m *PlayerMutation) AddedFields() []string {
 	if m.addvac_count != nil {
 		fields = append(fields, player.FieldVacCount)
 	}
+	if m.addgame_ban_count != nil {
+		fields = append(fields, player.FieldGameBanCount)
+	}
 	return fields
 }
 
@@ -2193,6 +2346,8 @@ func (m *PlayerMutation) AddedField(name string) (ent.Value, bool) {
 	switch name {
 	case player.FieldVacCount:
 		return m.AddedVacCount()
+	case player.FieldGameBanCount:
+		return m.AddedGameBanCount()
 	}
 	return nil, false
 }
@@ -2209,6 +2364,13 @@ func (m *PlayerMutation) AddField(name string, value ent.Value) error {
 		}
 		m.AddVacCount(v)
 		return nil
+	case player.FieldGameBanCount:
+		v, ok := value.(int)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddGameBanCount(v)
+		return nil
 	}
 	return fmt.Errorf("unknown Player numeric field %s", name)
 }
@@ -2235,6 +2397,12 @@ func (m *PlayerMutation) ClearedFields() []string {
 	if m.FieldCleared(player.FieldVacCount) {
 		fields = append(fields, player.FieldVacCount)
 	}
+	if m.FieldCleared(player.FieldGameBanDate) {
+		fields = append(fields, player.FieldGameBanDate)
+	}
+	if m.FieldCleared(player.FieldGameBanCount) {
+		fields = append(fields, player.FieldGameBanCount)
+	}
 	if m.FieldCleared(player.FieldSharecodeUpdated) {
 		fields = append(fields, player.FieldSharecodeUpdated)
 	}
@@ -2279,6 +2447,12 @@ func (m *PlayerMutation) ClearField(name string) error {
 	case player.FieldVacCount:
 		m.ClearVacCount()
 		return nil
+	case player.FieldGameBanDate:
+		m.ClearGameBanDate()
+		return nil
+	case player.FieldGameBanCount:
+		m.ClearGameBanCount()
+		return nil
 	case player.FieldSharecodeUpdated:
 		m.ClearSharecodeUpdated()
 		return nil
@@ -2317,6 +2491,12 @@ func (m *PlayerMutation) ResetField(name string) error {
 	case player.FieldVacCount:
 		m.ResetVacCount()
 		return nil
+	case player.FieldGameBanDate:
+		m.ResetGameBanDate()
+		return nil
+	case player.FieldGameBanCount:
+		m.ResetGameBanCount()
+		return nil
 	case player.FieldSteamUpdated:
 		m.ResetSteamUpdated()
 		return nil

ent/player.go

@@ -28,6 +28,10 @@ type Player struct {
 	VacDate time.Time `json:"vac_date,omitempty"`
 	// VacCount holds the value of the "vac_count" field.
 	VacCount int `json:"vac_count,omitempty"`
+	// GameBanDate holds the value of the "game_ban_date" field.
+	GameBanDate time.Time `json:"game_ban_date,omitempty"`
+	// GameBanCount holds the value of the "game_ban_count" field.
+	GameBanCount int `json:"game_ban_count,omitempty"`
 	// SteamUpdated holds the value of the "steam_updated" field.
 	SteamUpdated time.Time `json:"-"`
 	// SharecodeUpdated holds the value of the "sharecode_updated" field.
@@ -77,11 +81,11 @@ func (*Player) scanValues(columns []string) ([]interface{}, error) {
 	values := make([]interface{}, len(columns))
 	for i := range columns {
 		switch columns[i] {
-		case player.FieldID, player.FieldVacCount:
+		case player.FieldID, player.FieldVacCount, player.FieldGameBanCount:
 			values[i] = new(sql.NullInt64)
 		case player.FieldName, player.FieldAvatar, player.FieldVanityURL, player.FieldVanityURLReal, player.FieldAuthCode, player.FieldOldestSharecodeSeen:
 			values[i] = new(sql.NullString)
-		case player.FieldVacDate, player.FieldSteamUpdated, player.FieldSharecodeUpdated, player.FieldProfileCreated:
+		case player.FieldVacDate, player.FieldGameBanDate, player.FieldSteamUpdated, player.FieldSharecodeUpdated, player.FieldProfileCreated:
 			values[i] = new(sql.NullTime)
 		default:
 			return nil, fmt.Errorf("unexpected column %q for type Player", columns[i])
@@ -140,6 +144,18 @@ func (pl *Player) assignValues(columns []string, values []interface{}) error {
 			} else if value.Valid {
 				pl.VacCount = int(value.Int64)
 			}
+		case player.FieldGameBanDate:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field game_ban_date", values[i])
+			} else if value.Valid {
+				pl.GameBanDate = value.Time
+			}
+		case player.FieldGameBanCount:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field game_ban_count", values[i])
+			} else if value.Valid {
+				pl.GameBanCount = int(value.Int64)
+			}
 		case player.FieldSteamUpdated:
 			if value, ok := values[i].(*sql.NullTime); !ok {
 				return fmt.Errorf("unexpected type %T for field steam_updated", values[i])
@@ -220,6 +236,10 @@ func (pl *Player) String() string {
 	builder.WriteString(pl.VacDate.Format(time.ANSIC))
 	builder.WriteString(", vac_count=")
 	builder.WriteString(fmt.Sprintf("%v", pl.VacCount))
+	builder.WriteString(", game_ban_date=")
+	builder.WriteString(pl.GameBanDate.Format(time.ANSIC))
+	builder.WriteString(", game_ban_count=")
+	builder.WriteString(fmt.Sprintf("%v", pl.GameBanCount))
 	builder.WriteString(", steam_updated=")
 	builder.WriteString(pl.SteamUpdated.Format(time.ANSIC))
 	builder.WriteString(", sharecode_updated=")

ent/player/player.go

@@ -23,6 +23,10 @@ const (
 	FieldVacDate = "vac_date"
 	// FieldVacCount holds the string denoting the vac_count field in the database.
 	FieldVacCount = "vac_count"
+	// FieldGameBanDate holds the string denoting the game_ban_date field in the database.
+	FieldGameBanDate = "game_ban_date"
+	// FieldGameBanCount holds the string denoting the game_ban_count field in the database.
+	FieldGameBanCount = "game_ban_count"
 	// FieldSteamUpdated holds the string denoting the steam_updated field in the database.
 	FieldSteamUpdated = "steam_updated"
 	// FieldSharecodeUpdated holds the string denoting the sharecode_updated field in the database.
@@ -62,6 +66,8 @@ var Columns = []string{
 	FieldVanityURLReal,
 	FieldVacDate,
 	FieldVacCount,
+	FieldGameBanDate,
+	FieldGameBanCount,
 	FieldSteamUpdated,
 	FieldSharecodeUpdated,
 	FieldAuthCode,

ent/player/where.go

@@ -135,6 +135,20 @@ func VacCount(v int) predicate.Player {
 	})
 }
 
+// GameBanDate applies equality check predicate on the "game_ban_date" field. It's identical to GameBanDateEQ.
+func GameBanDate(v time.Time) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldGameBanDate), v))
+	})
+}
+
+// GameBanCount applies equality check predicate on the "game_ban_count" field. It's identical to GameBanCountEQ.
+func GameBanCount(v int) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldGameBanCount), v))
+	})
+}
+
 // SteamUpdated applies equality check predicate on the "steam_updated" field. It's identical to SteamUpdatedEQ.
 func SteamUpdated(v time.Time) predicate.Player {
 	return predicate.Player(func(s *sql.Selector) {
@@ -850,6 +864,186 @@ func VacCountNotNil() predicate.Player {
 	})
 }
 
+// GameBanDateEQ applies the EQ predicate on the "game_ban_date" field.
+func GameBanDateEQ(v time.Time) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldGameBanDate), v))
+	})
+}
+
+// GameBanDateNEQ applies the NEQ predicate on the "game_ban_date" field.
+func GameBanDateNEQ(v time.Time) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.NEQ(s.C(FieldGameBanDate), v))
+	})
+}
+
+// GameBanDateIn applies the In predicate on the "game_ban_date" field.
+func GameBanDateIn(vs ...time.Time) predicate.Player {
+	v := make([]interface{}, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.Player(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(v) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		s.Where(sql.In(s.C(FieldGameBanDate), v...))
+	})
+}
+
+// GameBanDateNotIn applies the NotIn predicate on the "game_ban_date" field.
+func GameBanDateNotIn(vs ...time.Time) predicate.Player {
+	v := make([]interface{}, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.Player(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(v) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		s.Where(sql.NotIn(s.C(FieldGameBanDate), v...))
+	})
+}
+
+// GameBanDateGT applies the GT predicate on the "game_ban_date" field.
+func GameBanDateGT(v time.Time) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.GT(s.C(FieldGameBanDate), v))
+	})
+}
+
+// GameBanDateGTE applies the GTE predicate on the "game_ban_date" field.
+func GameBanDateGTE(v time.Time) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.GTE(s.C(FieldGameBanDate), v))
+	})
+}
+
+// GameBanDateLT applies the LT predicate on the "game_ban_date" field.
+func GameBanDateLT(v time.Time) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.LT(s.C(FieldGameBanDate), v))
+	})
+}
+
+// GameBanDateLTE applies the LTE predicate on the "game_ban_date" field.
+func GameBanDateLTE(v time.Time) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.LTE(s.C(FieldGameBanDate), v))
+	})
+}
+
+// GameBanDateIsNil applies the IsNil predicate on the "game_ban_date" field.
+func GameBanDateIsNil() predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.IsNull(s.C(FieldGameBanDate)))
+	})
+}
+
+// GameBanDateNotNil applies the NotNil predicate on the "game_ban_date" field.
+func GameBanDateNotNil() predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.NotNull(s.C(FieldGameBanDate)))
+	})
+}
+
+// GameBanCountEQ applies the EQ predicate on the "game_ban_count" field.
+func GameBanCountEQ(v int) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldGameBanCount), v))
+	})
+}
+
+// GameBanCountNEQ applies the NEQ predicate on the "game_ban_count" field.
+func GameBanCountNEQ(v int) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.NEQ(s.C(FieldGameBanCount), v))
+	})
+}
+
+// GameBanCountIn applies the In predicate on the "game_ban_count" field.
+func GameBanCountIn(vs ...int) predicate.Player {
+	v := make([]interface{}, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.Player(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(v) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		s.Where(sql.In(s.C(FieldGameBanCount), v...))
+	})
+}
+
+// GameBanCountNotIn applies the NotIn predicate on the "game_ban_count" field.
+func GameBanCountNotIn(vs ...int) predicate.Player {
+	v := make([]interface{}, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.Player(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(v) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		s.Where(sql.NotIn(s.C(FieldGameBanCount), v...))
+	})
+}
+
+// GameBanCountGT applies the GT predicate on the "game_ban_count" field.
+func GameBanCountGT(v int) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.GT(s.C(FieldGameBanCount), v))
+	})
+}
+
+// GameBanCountGTE applies the GTE predicate on the "game_ban_count" field.
+func GameBanCountGTE(v int) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.GTE(s.C(FieldGameBanCount), v))
+	})
+}
+
+// GameBanCountLT applies the LT predicate on the "game_ban_count" field.
+func GameBanCountLT(v int) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.LT(s.C(FieldGameBanCount), v))
+	})
+}
+
+// GameBanCountLTE applies the LTE predicate on the "game_ban_count" field.
+func GameBanCountLTE(v int) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.LTE(s.C(FieldGameBanCount), v))
+	})
+}
+
+// GameBanCountIsNil applies the IsNil predicate on the "game_ban_count" field.
+func GameBanCountIsNil() predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.IsNull(s.C(FieldGameBanCount)))
+	})
+}
+
+// GameBanCountNotNil applies the NotNil predicate on the "game_ban_count" field.
+func GameBanCountNotNil() predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.NotNull(s.C(FieldGameBanCount)))
+	})
+}
+
 // SteamUpdatedEQ applies the EQ predicate on the "steam_updated" field.
 func SteamUpdatedEQ(v time.Time) predicate.Player {
 	return predicate.Player(func(s *sql.Selector) {

ent/player_create.go

@@ -106,6 +106,34 @@ func (pc *PlayerCreate) SetNillableVacCount(i *int) *PlayerCreate {
 	return pc
 }
 
+// SetGameBanDate sets the "game_ban_date" field.
+func (pc *PlayerCreate) SetGameBanDate(t time.Time) *PlayerCreate {
+	pc.mutation.SetGameBanDate(t)
+	return pc
+}
+
+// SetNillableGameBanDate sets the "game_ban_date" field if the given value is not nil.
+func (pc *PlayerCreate) SetNillableGameBanDate(t *time.Time) *PlayerCreate {
+	if t != nil {
+		pc.SetGameBanDate(*t)
+	}
+	return pc
+}
+
+// SetGameBanCount sets the "game_ban_count" field.
+func (pc *PlayerCreate) SetGameBanCount(i int) *PlayerCreate {
+	pc.mutation.SetGameBanCount(i)
+	return pc
+}
+
+// SetNillableGameBanCount sets the "game_ban_count" field if the given value is not nil.
+func (pc *PlayerCreate) SetNillableGameBanCount(i *int) *PlayerCreate {
+	if i != nil {
+		pc.SetGameBanCount(*i)
+	}
+	return pc
+}
+
 // SetSteamUpdated sets the "steam_updated" field.
 func (pc *PlayerCreate) SetSteamUpdated(t time.Time) *PlayerCreate {
 	pc.mutation.SetSteamUpdated(t)
@@ -375,6 +403,22 @@ func (pc *PlayerCreate) createSpec() (*Player, *sqlgraph.CreateSpec) {
 		})
 		_node.VacCount = value
 	}
+	if value, ok := pc.mutation.GameBanDate(); ok {
+		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
+			Type:   field.TypeTime,
+			Value:  value,
+			Column: player.FieldGameBanDate,
+		})
+		_node.GameBanDate = value
+	}
+	if value, ok := pc.mutation.GameBanCount(); ok {
+		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
+			Type:   field.TypeInt,
+			Value:  value,
+			Column: player.FieldGameBanCount,
+		})
+		_node.GameBanCount = value
+	}
 	if value, ok := pc.mutation.SteamUpdated(); ok {
 		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
 			Type:   field.TypeTime,

ent/player_update.go

@@ -156,6 +156,53 @@ func (pu *PlayerUpdate) ClearVacCount() *PlayerUpdate {
 	return pu
 }
 
+// SetGameBanDate sets the "game_ban_date" field.
+func (pu *PlayerUpdate) SetGameBanDate(t time.Time) *PlayerUpdate {
+	pu.mutation.SetGameBanDate(t)
+	return pu
+}
+
+// SetNillableGameBanDate sets the "game_ban_date" field if the given value is not nil.
+func (pu *PlayerUpdate) SetNillableGameBanDate(t *time.Time) *PlayerUpdate {
+	if t != nil {
+		pu.SetGameBanDate(*t)
+	}
+	return pu
+}
+
+// ClearGameBanDate clears the value of the "game_ban_date" field.
+func (pu *PlayerUpdate) ClearGameBanDate() *PlayerUpdate {
+	pu.mutation.ClearGameBanDate()
+	return pu
+}
+
+// SetGameBanCount sets the "game_ban_count" field.
+func (pu *PlayerUpdate) SetGameBanCount(i int) *PlayerUpdate {
+	pu.mutation.ResetGameBanCount()
+	pu.mutation.SetGameBanCount(i)
+	return pu
+}
+
+// SetNillableGameBanCount sets the "game_ban_count" field if the given value is not nil.
+func (pu *PlayerUpdate) SetNillableGameBanCount(i *int) *PlayerUpdate {
+	if i != nil {
+		pu.SetGameBanCount(*i)
+	}
+	return pu
+}
+
+// AddGameBanCount adds i to the "game_ban_count" field.
+func (pu *PlayerUpdate) AddGameBanCount(i int) *PlayerUpdate {
+	pu.mutation.AddGameBanCount(i)
+	return pu
+}
+
+// ClearGameBanCount clears the value of the "game_ban_count" field.
+func (pu *PlayerUpdate) ClearGameBanCount() *PlayerUpdate {
+	pu.mutation.ClearGameBanCount()
+	return pu
+}
+
 // SetSteamUpdated sets the "steam_updated" field.
 func (pu *PlayerUpdate) SetSteamUpdated(t time.Time) *PlayerUpdate {
 	pu.mutation.SetSteamUpdated(t)
@@ -484,6 +531,39 @@ func (pu *PlayerUpdate) sqlSave(ctx context.Context) (n int, err error) {
 			Column: player.FieldVacCount,
 		})
 	}
+	if value, ok := pu.mutation.GameBanDate(); ok {
+		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
+			Type:   field.TypeTime,
+			Value:  value,
+			Column: player.FieldGameBanDate,
+		})
+	}
+	if pu.mutation.GameBanDateCleared() {
+		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
+			Type:   field.TypeTime,
+			Column: player.FieldGameBanDate,
+		})
+	}
+	if value, ok := pu.mutation.GameBanCount(); ok {
+		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
+			Type:   field.TypeInt,
+			Value:  value,
+			Column: player.FieldGameBanCount,
+		})
+	}
+	if value, ok := pu.mutation.AddedGameBanCount(); ok {
+		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
+			Type:   field.TypeInt,
+			Value:  value,
+			Column: player.FieldGameBanCount,
+		})
+	}
+	if pu.mutation.GameBanCountCleared() {
+		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
+			Type:   field.TypeInt,
+			Column: player.FieldGameBanCount,
+		})
+	}
 	if value, ok := pu.mutation.SteamUpdated(); ok {
 		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
 			Type:   field.TypeTime,
@@ -797,6 +877,53 @@ func (puo *PlayerUpdateOne) ClearVacCount() *PlayerUpdateOne {
 	return puo
 }
 
+// SetGameBanDate sets the "game_ban_date" field.
+func (puo *PlayerUpdateOne) SetGameBanDate(t time.Time) *PlayerUpdateOne {
+	puo.mutation.SetGameBanDate(t)
+	return puo
+}
+
+// SetNillableGameBanDate sets the "game_ban_date" field if the given value is not nil.
+func (puo *PlayerUpdateOne) SetNillableGameBanDate(t *time.Time) *PlayerUpdateOne {
+	if t != nil {
+		puo.SetGameBanDate(*t)
+	}
+	return puo
+}
+
+// ClearGameBanDate clears the value of the "game_ban_date" field.
+func (puo *PlayerUpdateOne) ClearGameBanDate() *PlayerUpdateOne {
+	puo.mutation.ClearGameBanDate()
+	return puo
+}
+
+// SetGameBanCount sets the "game_ban_count" field.
+func (puo *PlayerUpdateOne) SetGameBanCount(i int) *PlayerUpdateOne {
+	puo.mutation.ResetGameBanCount()
+	puo.mutation.SetGameBanCount(i)
+	return puo
+}
+
+// SetNillableGameBanCount sets the "game_ban_count" field if the given value is not nil.
+func (puo *PlayerUpdateOne) SetNillableGameBanCount(i *int) *PlayerUpdateOne {
+	if i != nil {
+		puo.SetGameBanCount(*i)
+	}
+	return puo
+}
+
+// AddGameBanCount adds i to the "game_ban_count" field.
+func (puo *PlayerUpdateOne) AddGameBanCount(i int) *PlayerUpdateOne {
+	puo.mutation.AddGameBanCount(i)
+	return puo
+}
+
+// ClearGameBanCount clears the value of the "game_ban_count" field.
+func (puo *PlayerUpdateOne) ClearGameBanCount() *PlayerUpdateOne {
+	puo.mutation.ClearGameBanCount()
+	return puo
+}
+
 // SetSteamUpdated sets the "steam_updated" field.
 func (puo *PlayerUpdateOne) SetSteamUpdated(t time.Time) *PlayerUpdateOne {
 	puo.mutation.SetSteamUpdated(t)
@@ -1149,6 +1276,39 @@ func (puo *PlayerUpdateOne) sqlSave(ctx context.Context) (_node *Player, err err
 			Column: player.FieldVacCount,
 		})
 	}
+	if value, ok := puo.mutation.GameBanDate(); ok {
+		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
+			Type:   field.TypeTime,
+			Value:  value,
+			Column: player.FieldGameBanDate,
+		})
+	}
+	if puo.mutation.GameBanDateCleared() {
+		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
+			Type:   field.TypeTime,
+			Column: player.FieldGameBanDate,
+		})
+	}
+	if value, ok := puo.mutation.GameBanCount(); ok {
+		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
+			Type:   field.TypeInt,
+			Value:  value,
+			Column: player.FieldGameBanCount,
+		})
+	}
+	if value, ok := puo.mutation.AddedGameBanCount(); ok {
+		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
+			Type:   field.TypeInt,
+			Value:  value,
+			Column: player.FieldGameBanCount,
+		})
+	}
+	if puo.mutation.GameBanCountCleared() {
+		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
+			Type:   field.TypeInt,
+			Column: player.FieldGameBanCount,
+		})
+	}
 	if value, ok := puo.mutation.SteamUpdated(); ok {
 		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
 			Type:   field.TypeTime,

ent/runtime.go

@@ -22,7 +22,7 @@ func init() {
 	playerFields := schema.Player{}.Fields()
 	_ = playerFields
 	// playerDescSteamUpdated is the schema descriptor for steam_updated field.
-	playerDescSteamUpdated := playerFields[7].Descriptor()
+	playerDescSteamUpdated := playerFields[9].Descriptor()
 	// player.DefaultSteamUpdated holds the default value on creation for the steam_updated field.
 	player.DefaultSteamUpdated = playerDescSteamUpdated.Default.(func() time.Time)
 }

ent/schema/player.go

@@ -22,6 +22,8 @@ func (Player) Fields() []ent.Field {
 		field.String("vanity_url_real").Optional(),
 		field.Time("vac_date").Optional(),
 		field.Int("vac_count").Optional(),
+		field.Time("game_ban_date").Optional(),
+		field.Int("game_ban_count").Optional(),
 		field.Time("steam_updated").Default(func() time.Time {
 			return time.Now().UTC()
 		}).StructTag(`json:"-"`),