fill history if an older match appeared

ent/migrate/schema.go

@@ -42,6 +42,7 @@ var (
 		{Name: "sharecode_updated", Type: field.TypeTime, Nullable: true},
 		{Name: "auth_code", Type: field.TypeString, Nullable: true},
 		{Name: "profile_created", Type: field.TypeTime, Nullable: true},
+		{Name: "oldest_sharecode_seen", Type: field.TypeString, Nullable: true},
 	}
 	// PlayersTable holds the schema information for the "players" table.
 	PlayersTable = &schema.Table{

ent/mutation.go

@@ -1205,31 +1205,32 @@ func (m *MatchMutation) ResetEdge(name string) error {
 // PlayerMutation represents an operation that mutates the Player nodes in the graph.
 type PlayerMutation struct {
 	config
-	op                Op
+	op                    Op
-	typ               string
+	typ                   string
-	id                *uint64
+	id                    *uint64
-	name              *string
+	name                  *string
-	avatar            *string
+	avatar                *string
-	vanity_url        *string
+	vanity_url            *string
-	vanity_url_real   *string
+	vanity_url_real       *string
-	vac               *bool
+	vac                   *bool
-	vac_date          *time.Time
+	vac_date              *time.Time
-	vac_count         *int
+	vac_count             *int
-	addvac_count      *int
+	addvac_count          *int
-	steam_updated     *time.Time
+	steam_updated         *time.Time
-	sharecode_updated *time.Time
+	sharecode_updated     *time.Time
-	auth_code         *string
+	auth_code             *string
-	profile_created   *time.Time
+	profile_created       *time.Time
-	clearedFields     map[string]struct{}
+	oldest_sharecode_seen *string
-	stats             map[int]struct{}
+	clearedFields         map[string]struct{}
-	removedstats      map[int]struct{}
+	stats                 map[int]struct{}
-	clearedstats      bool
+	removedstats          map[int]struct{}
-	matches           map[uint64]struct{}
+	clearedstats          bool
-	removedmatches    map[uint64]struct{}
+	matches               map[uint64]struct{}
-	clearedmatches    bool
+	removedmatches        map[uint64]struct{}
-	done              bool
+	clearedmatches        bool
-	oldValue          func(context.Context) (*Player, error)
+	done                  bool
-	predicates        []predicate.Player
+	oldValue              func(context.Context) (*Player, error)
+	predicates            []predicate.Player
 }
 
 var _ ent.Mutation = (*PlayerMutation)(nil)
@@ -1851,6 +1852,55 @@ func (m *PlayerMutation) ResetProfileCreated() {
 	delete(m.clearedFields, player.FieldProfileCreated)
 }
 
+// SetOldestSharecodeSeen sets the "oldest_sharecode_seen" field.
+func (m *PlayerMutation) SetOldestSharecodeSeen(s string) {
+	m.oldest_sharecode_seen = &s
+}
+
+// OldestSharecodeSeen returns the value of the "oldest_sharecode_seen" field in the mutation.
+func (m *PlayerMutation) OldestSharecodeSeen() (r string, exists bool) {
+	v := m.oldest_sharecode_seen
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldOldestSharecodeSeen returns the old "oldest_sharecode_seen" 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) OldOldestSharecodeSeen(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, fmt.Errorf("OldOldestSharecodeSeen is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, fmt.Errorf("OldOldestSharecodeSeen requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldOldestSharecodeSeen: %w", err)
+	}
+	return oldValue.OldestSharecodeSeen, nil
+}
+
+// ClearOldestSharecodeSeen clears the value of the "oldest_sharecode_seen" field.
+func (m *PlayerMutation) ClearOldestSharecodeSeen() {
+	m.oldest_sharecode_seen = nil
+	m.clearedFields[player.FieldOldestSharecodeSeen] = struct{}{}
+}
+
+// OldestSharecodeSeenCleared returns if the "oldest_sharecode_seen" field was cleared in this mutation.
+func (m *PlayerMutation) OldestSharecodeSeenCleared() bool {
+	_, ok := m.clearedFields[player.FieldOldestSharecodeSeen]
+	return ok
+}
+
+// ResetOldestSharecodeSeen resets all changes to the "oldest_sharecode_seen" field.
+func (m *PlayerMutation) ResetOldestSharecodeSeen() {
+	m.oldest_sharecode_seen = nil
+	delete(m.clearedFields, player.FieldOldestSharecodeSeen)
+}
+
 // AddStatIDs adds the "stats" edge to the Stats entity by ids.
 func (m *PlayerMutation) AddStatIDs(ids ...int) {
 	if m.stats == nil {
@@ -1978,7 +2028,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, 12)
 	if m.name != nil {
 		fields = append(fields, player.FieldName)
 	}
@@ -2012,6 +2062,9 @@ func (m *PlayerMutation) Fields() []string {
 	if m.profile_created != nil {
 		fields = append(fields, player.FieldProfileCreated)
 	}
+	if m.oldest_sharecode_seen != nil {
+		fields = append(fields, player.FieldOldestSharecodeSeen)
+	}
 	return fields
 }
 
@@ -2042,6 +2095,8 @@ func (m *PlayerMutation) Field(name string) (ent.Value, bool) {
 		return m.AuthCode()
 	case player.FieldProfileCreated:
 		return m.ProfileCreated()
+	case player.FieldOldestSharecodeSeen:
+		return m.OldestSharecodeSeen()
 	}
 	return nil, false
 }
@@ -2073,6 +2128,8 @@ func (m *PlayerMutation) OldField(ctx context.Context, name string) (ent.Value,
 		return m.OldAuthCode(ctx)
 	case player.FieldProfileCreated:
 		return m.OldProfileCreated(ctx)
+	case player.FieldOldestSharecodeSeen:
+		return m.OldOldestSharecodeSeen(ctx)
 	}
 	return nil, fmt.Errorf("unknown Player field %s", name)
 }
@@ -2159,6 +2216,13 @@ func (m *PlayerMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetProfileCreated(v)
 		return nil
+	case player.FieldOldestSharecodeSeen:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetOldestSharecodeSeen(v)
+		return nil
 	}
 	return fmt.Errorf("unknown Player field %s", name)
 }
@@ -2231,6 +2295,9 @@ func (m *PlayerMutation) ClearedFields() []string {
 	if m.FieldCleared(player.FieldProfileCreated) {
 		fields = append(fields, player.FieldProfileCreated)
 	}
+	if m.FieldCleared(player.FieldOldestSharecodeSeen) {
+		fields = append(fields, player.FieldOldestSharecodeSeen)
+	}
 	return fields
 }
 
@@ -2272,6 +2339,9 @@ func (m *PlayerMutation) ClearField(name string) error {
 	case player.FieldProfileCreated:
 		m.ClearProfileCreated()
 		return nil
+	case player.FieldOldestSharecodeSeen:
+		m.ClearOldestSharecodeSeen()
+		return nil
 	}
 	return fmt.Errorf("unknown Player nullable field %s", name)
 }
@@ -2313,6 +2383,9 @@ func (m *PlayerMutation) ResetField(name string) error {
 	case player.FieldProfileCreated:
 		m.ResetProfileCreated()
 		return nil
+	case player.FieldOldestSharecodeSeen:
+		m.ResetOldestSharecodeSeen()
+		return nil
 	}
 	return fmt.Errorf("unknown Player field %s", name)
 }

ent/player.go

@@ -38,6 +38,8 @@ type Player struct {
 	AuthCode string `json:"-"`
 	// ProfileCreated holds the value of the "profile_created" field.
 	ProfileCreated time.Time `json:"profile_created,omitempty"`
+	// OldestSharecodeSeen holds the value of the "oldest_sharecode_seen" field.
+	OldestSharecodeSeen string `json:"oldest_sharecode_seen,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
 	// The values are being populated by the PlayerQuery when eager-loading is set.
 	Edges PlayerEdges `json:"edges"`
@@ -81,7 +83,7 @@ func (*Player) scanValues(columns []string) ([]interface{}, error) {
 			values[i] = new(sql.NullBool)
 		case player.FieldID, player.FieldVacCount:
 			values[i] = new(sql.NullInt64)
-		case player.FieldName, player.FieldAvatar, player.FieldVanityURL, player.FieldVanityURLReal, player.FieldAuthCode:
+		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:
 			values[i] = new(sql.NullTime)
@@ -172,6 +174,12 @@ func (pl *Player) assignValues(columns []string, values []interface{}) error {
 			} else if value.Valid {
 				pl.ProfileCreated = value.Time
 			}
+		case player.FieldOldestSharecodeSeen:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field oldest_sharecode_seen", values[i])
+			} else if value.Valid {
+				pl.OldestSharecodeSeen = value.String
+			}
 		}
 	}
 	return nil
@@ -231,6 +239,8 @@ func (pl *Player) String() string {
 	builder.WriteString(", auth_code=<sensitive>")
 	builder.WriteString(", profile_created=")
 	builder.WriteString(pl.ProfileCreated.Format(time.ANSIC))
+	builder.WriteString(", oldest_sharecode_seen=")
+	builder.WriteString(pl.OldestSharecodeSeen)
 	builder.WriteByte(')')
 	return builder.String()
 }

ent/player/player.go

@@ -33,6 +33,8 @@ const (
 	FieldAuthCode = "auth_code"
 	// FieldProfileCreated holds the string denoting the profile_created field in the database.
 	FieldProfileCreated = "profile_created"
+	// FieldOldestSharecodeSeen holds the string denoting the oldest_sharecode_seen field in the database.
+	FieldOldestSharecodeSeen = "oldest_sharecode_seen"
 	// EdgeStats holds the string denoting the stats edge name in mutations.
 	EdgeStats = "stats"
 	// EdgeMatches holds the string denoting the matches edge name in mutations.
@@ -67,6 +69,7 @@ var Columns = []string{
 	FieldSharecodeUpdated,
 	FieldAuthCode,
 	FieldProfileCreated,
+	FieldOldestSharecodeSeen,
 }
 
 var (

ent/player/where.go

@@ -170,6 +170,13 @@ func ProfileCreated(v time.Time) predicate.Player {
 	})
 }
 
+// OldestSharecodeSeen applies equality check predicate on the "oldest_sharecode_seen" field. It's identical to OldestSharecodeSeenEQ.
+func OldestSharecodeSeen(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
 // NameEQ applies the EQ predicate on the "name" field.
 func NameEQ(v string) predicate.Player {
 	return predicate.Player(func(s *sql.Selector) {
@@ -1245,6 +1252,131 @@ func ProfileCreatedNotNil() predicate.Player {
 	})
 }
 
+// OldestSharecodeSeenEQ applies the EQ predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenEQ(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
+// OldestSharecodeSeenNEQ applies the NEQ predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenNEQ(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.NEQ(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
+// OldestSharecodeSeenIn applies the In predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenIn(vs ...string) 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(FieldOldestSharecodeSeen), v...))
+	})
+}
+
+// OldestSharecodeSeenNotIn applies the NotIn predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenNotIn(vs ...string) 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(FieldOldestSharecodeSeen), v...))
+	})
+}
+
+// OldestSharecodeSeenGT applies the GT predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenGT(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.GT(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
+// OldestSharecodeSeenGTE applies the GTE predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenGTE(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.GTE(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
+// OldestSharecodeSeenLT applies the LT predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenLT(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.LT(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
+// OldestSharecodeSeenLTE applies the LTE predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenLTE(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.LTE(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
+// OldestSharecodeSeenContains applies the Contains predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenContains(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.Contains(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
+// OldestSharecodeSeenHasPrefix applies the HasPrefix predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenHasPrefix(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.HasPrefix(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
+// OldestSharecodeSeenHasSuffix applies the HasSuffix predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenHasSuffix(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.HasSuffix(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
+// OldestSharecodeSeenIsNil applies the IsNil predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenIsNil() predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.IsNull(s.C(FieldOldestSharecodeSeen)))
+	})
+}
+
+// OldestSharecodeSeenNotNil applies the NotNil predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenNotNil() predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.NotNull(s.C(FieldOldestSharecodeSeen)))
+	})
+}
+
+// OldestSharecodeSeenEqualFold applies the EqualFold predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenEqualFold(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.EqualFold(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
+// OldestSharecodeSeenContainsFold applies the ContainsFold predicate on the "oldest_sharecode_seen" field.
+func OldestSharecodeSeenContainsFold(v string) predicate.Player {
+	return predicate.Player(func(s *sql.Selector) {
+		s.Where(sql.ContainsFold(s.C(FieldOldestSharecodeSeen), v))
+	})
+}
+
 // HasStats applies the HasEdge predicate on the "stats" edge.
 func HasStats() predicate.Player {
 	return predicate.Player(func(s *sql.Selector) {

ent/player_create.go

@@ -176,6 +176,20 @@ func (pc *PlayerCreate) SetNillableProfileCreated(t *time.Time) *PlayerCreate {
 	return pc
 }
 
+// SetOldestSharecodeSeen sets the "oldest_sharecode_seen" field.
+func (pc *PlayerCreate) SetOldestSharecodeSeen(s string) *PlayerCreate {
+	pc.mutation.SetOldestSharecodeSeen(s)
+	return pc
+}
+
+// SetNillableOldestSharecodeSeen sets the "oldest_sharecode_seen" field if the given value is not nil.
+func (pc *PlayerCreate) SetNillableOldestSharecodeSeen(s *string) *PlayerCreate {
+	if s != nil {
+		pc.SetOldestSharecodeSeen(*s)
+	}
+	return pc
+}
+
 // SetID sets the "id" field.
 func (pc *PlayerCreate) SetID(u uint64) *PlayerCreate {
 	pc.mutation.SetID(u)
@@ -422,6 +436,14 @@ func (pc *PlayerCreate) createSpec() (*Player, *sqlgraph.CreateSpec) {
 		})
 		_node.ProfileCreated = value
 	}
+	if value, ok := pc.mutation.OldestSharecodeSeen(); ok {
+		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
+			Type:   field.TypeString,
+			Value:  value,
+			Column: player.FieldOldestSharecodeSeen,
+		})
+		_node.OldestSharecodeSeen = value
+	}
 	if nodes := pc.mutation.StatsIDs(); len(nodes) > 0 {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,

ent/player_update.go

@@ -244,6 +244,26 @@ func (pu *PlayerUpdate) ClearProfileCreated() *PlayerUpdate {
 	return pu
 }
 
+// SetOldestSharecodeSeen sets the "oldest_sharecode_seen" field.
+func (pu *PlayerUpdate) SetOldestSharecodeSeen(s string) *PlayerUpdate {
+	pu.mutation.SetOldestSharecodeSeen(s)
+	return pu
+}
+
+// SetNillableOldestSharecodeSeen sets the "oldest_sharecode_seen" field if the given value is not nil.
+func (pu *PlayerUpdate) SetNillableOldestSharecodeSeen(s *string) *PlayerUpdate {
+	if s != nil {
+		pu.SetOldestSharecodeSeen(*s)
+	}
+	return pu
+}
+
+// ClearOldestSharecodeSeen clears the value of the "oldest_sharecode_seen" field.
+func (pu *PlayerUpdate) ClearOldestSharecodeSeen() *PlayerUpdate {
+	pu.mutation.ClearOldestSharecodeSeen()
+	return pu
+}
+
 // AddStatIDs adds the "stats" edge to the Stats entity by IDs.
 func (pu *PlayerUpdate) AddStatIDs(ids ...int) *PlayerUpdate {
 	pu.mutation.AddStatIDs(ids...)
@@ -531,6 +551,19 @@ func (pu *PlayerUpdate) sqlSave(ctx context.Context) (n int, err error) {
 			Column: player.FieldProfileCreated,
 		})
 	}
+	if value, ok := pu.mutation.OldestSharecodeSeen(); ok {
+		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
+			Type:   field.TypeString,
+			Value:  value,
+			Column: player.FieldOldestSharecodeSeen,
+		})
+	}
+	if pu.mutation.OldestSharecodeSeenCleared() {
+		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
+			Type:   field.TypeString,
+			Column: player.FieldOldestSharecodeSeen,
+		})
+	}
 	if pu.mutation.StatsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,
@@ -873,6 +906,26 @@ func (puo *PlayerUpdateOne) ClearProfileCreated() *PlayerUpdateOne {
 	return puo
 }
 
+// SetOldestSharecodeSeen sets the "oldest_sharecode_seen" field.
+func (puo *PlayerUpdateOne) SetOldestSharecodeSeen(s string) *PlayerUpdateOne {
+	puo.mutation.SetOldestSharecodeSeen(s)
+	return puo
+}
+
+// SetNillableOldestSharecodeSeen sets the "oldest_sharecode_seen" field if the given value is not nil.
+func (puo *PlayerUpdateOne) SetNillableOldestSharecodeSeen(s *string) *PlayerUpdateOne {
+	if s != nil {
+		puo.SetOldestSharecodeSeen(*s)
+	}
+	return puo
+}
+
+// ClearOldestSharecodeSeen clears the value of the "oldest_sharecode_seen" field.
+func (puo *PlayerUpdateOne) ClearOldestSharecodeSeen() *PlayerUpdateOne {
+	puo.mutation.ClearOldestSharecodeSeen()
+	return puo
+}
+
 // AddStatIDs adds the "stats" edge to the Stats entity by IDs.
 func (puo *PlayerUpdateOne) AddStatIDs(ids ...int) *PlayerUpdateOne {
 	puo.mutation.AddStatIDs(ids...)
@@ -1184,6 +1237,19 @@ func (puo *PlayerUpdateOne) sqlSave(ctx context.Context) (_node *Player, err err
 			Column: player.FieldProfileCreated,
 		})
 	}
+	if value, ok := puo.mutation.OldestSharecodeSeen(); ok {
+		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
+			Type:   field.TypeString,
+			Value:  value,
+			Column: player.FieldOldestSharecodeSeen,
+		})
+	}
+	if puo.mutation.OldestSharecodeSeenCleared() {
+		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
+			Type:   field.TypeString,
+			Column: player.FieldOldestSharecodeSeen,
+		})
+	}
 	if puo.mutation.StatsCleared() {
 		edge := &sqlgraph.EdgeSpec{
 			Rel:     sqlgraph.O2M,

ent/schema/player.go

@@ -29,6 +29,7 @@ func (Player) Fields() []ent.Field {
 		field.Time("sharecode_updated").Optional().StructTag(`json:"-"`),
 		field.String("auth_code").Optional().Sensitive(),
 		field.Time("profile_created").Optional(),
+		field.String("oldest_sharecode_seen").Optional(),
 	}
 }
 

utils/utils.go

@@ -271,17 +271,30 @@ func IsAuthCodeValid(player *ent.Player, lock *sync.RWMutex, apiKey string, shar
 
 func GetNewShareCodesForPlayer(player *ent.Player, lock *sync.RWMutex, apiKey string, rl ratelimit.Limiter) ([]string, error) {
 	lock.RLock()
-	tMatch, err := player.QueryMatches().Order(ent.Desc(match.FieldDate)).First(context.Background())
+	latestMatch, err := player.QueryMatches().Order(ent.Desc(match.FieldDate)).First(context.Background())
 	lock.RUnlock()
 	if err != nil {
 		return nil, err
 	}
-	var rCodes []string
+
-	newShareCode, err := getNextShareCode(tMatch.ShareCode, apiKey, player.AuthCode, player.ID, rl)
+	lock.RLock()
+	oldestMatch, err := player.QueryMatches().Order(ent.Asc(match.FieldDate)).First(context.Background())
+	lock.RUnlock()
 	if err != nil {
 		return nil, err
 	}
 
+	var newShareCode string
+	if oldestMatch.ShareCode == player.OldestSharecodeSeen {
+		newShareCode, err = getNextShareCode(latestMatch.ShareCode, apiKey, player.AuthCode, player.ID, rl)
+	} else {
+		newShareCode, err = getNextShareCode(oldestMatch.ShareCode, apiKey, player.AuthCode, player.ID, rl)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	var rCodes []string
 	for newShareCode != "n/a" {
 		rCodes = append(rCodes, newShareCode)
 		newShareCode, err = getNextShareCode(rCodes[len(rCodes)-1], apiKey, player.AuthCode, player.ID, rl)
@@ -292,7 +305,7 @@ func GetNewShareCodesForPlayer(player *ent.Player, lock *sync.RWMutex, apiKey st
 	}
 
 	lock.Lock()
-	err = player.Update().SetSharecodeUpdated(time.Now().UTC()).Exec(context.Background())
+	err = player.Update().SetSharecodeUpdated(time.Now().UTC()).SetOldestSharecodeSeen(oldestMatch.ShareCode).Exec(context.Background())
 	lock.Unlock()
 	if err != nil {
 		return nil, err