From b39efe9d9afb0781e73178eae21122488e4696c9 Mon Sep 17 00:00:00 2001 From: Giovanni Harting <539@idlegandalf.com> Date: Thu, 21 Oct 2021 16:50:30 +0200 Subject: [PATCH] fill history if an older match appeared --- ent/migrate/schema.go | 1 + ent/mutation.go | 125 ++++++++++++++++++++++++++++++--------- ent/player.go | 12 +++- ent/player/player.go | 3 + ent/player/where.go | 132 ++++++++++++++++++++++++++++++++++++++++++ ent/player_create.go | 22 +++++++ ent/player_update.go | 66 +++++++++++++++++++++ ent/schema/player.go | 1 + utils/utils.go | 21 +++++-- 9 files changed, 352 insertions(+), 31 deletions(-) diff --git a/ent/migrate/schema.go b/ent/migrate/schema.go index 81dd04b..89234e8 100644 --- a/ent/migrate/schema.go +++ b/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{ diff --git a/ent/mutation.go b/ent/mutation.go index 36b9ca0..e46d6bc 100644 --- a/ent/mutation.go +++ b/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 - typ string - id *uint64 - name *string - avatar *string - vanity_url *string - vanity_url_real *string - vac *bool - vac_date *time.Time - vac_count *int - addvac_count *int - steam_updated *time.Time - sharecode_updated *time.Time - auth_code *string - profile_created *time.Time - clearedFields map[string]struct{} - stats map[int]struct{} - removedstats map[int]struct{} - clearedstats bool - matches map[uint64]struct{} - removedmatches map[uint64]struct{} - clearedmatches bool - done bool - oldValue func(context.Context) (*Player, error) - predicates []predicate.Player + op Op + typ string + id *uint64 + name *string + avatar *string + vanity_url *string + vanity_url_real *string + vac *bool + vac_date *time.Time + vac_count *int + addvac_count *int + steam_updated *time.Time + sharecode_updated *time.Time + auth_code *string + profile_created *time.Time + oldest_sharecode_seen *string + clearedFields map[string]struct{} + stats map[int]struct{} + removedstats map[int]struct{} + clearedstats bool + matches map[uint64]struct{} + removedmatches map[uint64]struct{} + clearedmatches bool + done bool + 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) } diff --git a/ent/player.go b/ent/player.go index d5b0dfd..57dfb42 100644 --- a/ent/player.go +++ b/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=") 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() } diff --git a/ent/player/player.go b/ent/player/player.go index c9f2452..4a223bc 100644 --- a/ent/player/player.go +++ b/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 ( diff --git a/ent/player/where.go b/ent/player/where.go index bb31754..7de79fb 100644 --- a/ent/player/where.go +++ b/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) { diff --git a/ent/player_create.go b/ent/player_create.go index 726809f..5fe0208 100644 --- a/ent/player_create.go +++ b/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, diff --git a/ent/player_update.go b/ent/player_update.go index 9b6b0a1..18a9424 100644 --- a/ent/player_update.go +++ b/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, diff --git a/ent/schema/player.go b/ent/schema/player.go index fa54c06..0ace32c 100644 --- a/ent/schema/player.go +++ b/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(), } } diff --git a/utils/utils.go b/utils/utils.go index 5789d87..1a914f7 100644 --- a/utils/utils.go +++ b/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