update some apis to use the continuity timestamp

Author: tudddorrr

src/services/api/game-feedback-api.service.ts

@@ -40,6 +40,9 @@ export default class GameFeedbackAPIService extends APIService {
     const feedback = new GameFeedback(category, req.ctx.state.playerAlias)
     feedback.comment = comment
     feedback.anonymised = category.anonymised
+    if (req.ctx.state.continuityDate) {
+      feedback.createdAt = req.ctx.state.continuityDate
+    }
 
     await em.persistAndFlush(feedback)
 

src/services/api/game-stat-api.service.ts

@@ -52,6 +52,10 @@ export default class GameStatAPIService extends APIService {
 
     if (!playerStat) {
       playerStat = new PlayerGameStat(req.ctx.state.player, req.ctx.state.stat)
+      if (req.ctx.state.continuityDate) {
+        playerStat.createdAt = req.ctx.state.continuityDate
+      }
+
       em.persist(playerStat)
     }
 

src/services/api/leaderboard-api.service.ts

@@ -37,6 +37,9 @@ export default class LeaderboardAPIService extends APIService {
     const entry = new LeaderboardEntry(req.ctx.state.leaderboard)
     entry.playerAlias = req.ctx.state.playerAlias
     entry.score = req.body.score
+    if (req.ctx.state.continuityDate) {
+      entry.createdAt = req.ctx.state.continuityDate
+    }
 
     await em.persistAndFlush(entry)
 
@@ -67,7 +70,7 @@ export default class LeaderboardAPIService extends APIService {
 
         if ((leaderboard.sortMode === LeaderboardSortMode.ASC && score < entry.score) || (leaderboard.sortMode === LeaderboardSortMode.DESC && score > entry.score)) {
           entry.score = score
-          entry.createdAt = new Date()
+          entry.createdAt = req.ctx.state.continuityDate ?? new Date()
           await em.flush()
 
           updated = true

src/services/player.service.ts

@@ -84,6 +84,10 @@ export default class PlayerService extends Service {
     const game = await em.getRepository(Game).findOne(req.ctx.state.game)
 
     const player = new Player(game)
+    if (req.ctx.state.continuityDate) {
+      player.createdAt = req.ctx.state.continuityDate
+    }
+
     if (aliases) {
       for await (const alias of aliases) {
         if (await em.getRepository(PlayerAlias).count({ service: alias.service, identifier: alias.identifier }) > 0) {
@@ -98,6 +102,10 @@ export default class PlayerService extends Service {
         const alias = new PlayerAlias()
         alias.service = item.service
         alias.identifier = item.identifier
+        if (req.ctx.state.continuityDate) {
+          alias.createdAt = req.ctx.state.continuityDate
+        }
+
         return alias
       }))
     }

tests/services/_api/game-feedback-api/post.test.ts

@@ -4,6 +4,7 @@ import { APIKeyScope } from '../../../../src/entities/api-key'
 import createAPIKeyAndToken from '../../../utils/createAPIKeyAndToken'
 import GameFeedbackCategoryFactory from '../../../fixtures/GameFeedbackCategoryFactory'
 import PlayerFactory from '../../../fixtures/PlayerFactory'
+import { subHours } from 'date-fns'
 
 describe('Game feedback API service - post', () => {
   it('should create feedback if the scope is valid', async () => {
@@ -76,4 +77,25 @@ describe('Game feedback API service - post', () => {
 
     expect(res.body).toStrictEqual({ message: 'Feedback category not found' })
   })
+
+  it('should set the createdAt for the feedback to the continuity date', async () => {
+    const [apiKey, token] = await createAPIKeyAndToken([APIKeyScope.WRITE_GAME_FEEDBACK])
+
+    const feedbackCategory = await new GameFeedbackCategoryFactory(apiKey.game).one()
+    const player = await new PlayerFactory([apiKey.game]).one()
+
+    await (<EntityManager>global.em).persistAndFlush([feedbackCategory, player])
+
+    const continuityDate = subHours(new Date(), 1)
+
+    const res = await request(global.app)
+      .post(`/v1/game-feedback/categories/${feedbackCategory.internalName}`)
+      .send({ comment: 'This is my comment' })
+      .auth(token, { type: 'bearer' })
+      .set('x-talo-alias', String(player.aliases[0].id))
+      .set('x-talo-continuity-timestamp', String(continuityDate.getTime()))
+      .expect(200)
+
+    expect(res.body.feedback.createdAt).toBe(continuityDate.toISOString())
+  })
 })

tests/services/_api/game-stat-api/put.test.ts

@@ -7,6 +7,7 @@ import GameStat from '../../../../src/entities/game-stat'
 import PlayerGameStatFactory from '../../../fixtures/PlayerGameStatFactory'
 import createAPIKeyAndToken from '../../../utils/createAPIKeyAndToken'
 import Game from '../../../../src/entities/game'
+import { subHours } from 'date-fns'
 
 describe('Game stats API service - put', () => {
   const createStat = async (game: Game, props: Partial<GameStat>) => {
@@ -228,4 +229,23 @@ describe('Game stats API service - put', () => {
 
     expect(res.body).toStrictEqual({ message: 'Stat not found' })
   })
+
+  it('should set the createdAt of the player stat to the continuity date', async () => {
+    const [apiKey, token] = await createAPIKeyAndToken([APIKeyScope.WRITE_GAME_STATS])
+    const stat = await createStat(apiKey.game, { maxValue: 999, maxChange: 99 })
+    const player = await new PlayerFactory([apiKey.game]).one()
+    await (<EntityManager>global.em).persistAndFlush(player)
+
+    const continuityDate = subHours(new Date(), 1)
+
+    const res = await request(global.app)
+      .put(`/v1/game-stats/${stat.internalName}`)
+      .send({ change: 10 })
+      .auth(token, { type: 'bearer' })
+      .set('x-talo-player', player.id)
+      .set('x-talo-continuity-timestamp', String(continuityDate.getTime()))
+      .expect(200)
+
+    expect(res.body.playerStat.createdAt).toBe(continuityDate.toISOString())
+  })
 })

tests/services/_api/leaderboard-api/post.test.ts

@@ -220,4 +220,50 @@ describe('Leaderboard API service - post', () => {
 
     expect(res.body.entry.position).toBe(0)
   })
+
+  it('should set the createdAt for the entry to the continuity date', async () => {
+    const [apiKey, token] = await createAPIKeyAndToken([APIKeyScope.WRITE_LEADERBOARDS])
+    const player = await new PlayerFactory([apiKey.game]).one()
+    const leaderboard = await new LeaderboardFactory([apiKey.game]).one()
+    await (<EntityManager>global.em).persistAndFlush([player, leaderboard])
+
+    const continuityDate = subHours(new Date(), 1)
+
+    const res = await request(global.app)
+      .post(`/v1/leaderboards/${leaderboard.internalName}/entries`)
+      .send({ score: 300 })
+      .auth(token, { type: 'bearer' })
+      .set('x-talo-alias', String(player.aliases[0].id))
+      .set('x-talo-continuity-timestamp', String(continuityDate.getTime()))
+      .expect(200)
+
+    expect(new Date(res.body.entry.createdAt).getHours()).toBe(continuityDate.getHours())
+  })
+
+  it('should update an existing entry\'s created at to the continuity date for unique leaderboards', async () => {
+    const [apiKey, token] = await createAPIKeyAndToken([APIKeyScope.WRITE_LEADERBOARDS])
+    const player = await new PlayerFactory([apiKey.game]).one()
+    const leaderboard = await new LeaderboardFactory([apiKey.game]).state(() => ({ unique: true, sortMode: LeaderboardSortMode.DESC })).one()
+
+    const originalDate = subHours(new Date(), 2)
+    const continuityDate = subHours(new Date(), 1)
+
+    const entry = await new LeaderboardEntryFactory(leaderboard, [player]).state(() => ({
+      score: 100,
+      createdAt: originalDate,
+      playerAlias: player.aliases[0]
+    })).one()
+
+    await (<EntityManager>global.em).persistAndFlush([player, leaderboard, entry])
+
+    const res = await request(global.app)
+      .post(`/v1/leaderboards/${leaderboard.internalName}/entries`)
+      .send({ score: 300 })
+      .auth(token, { type: 'bearer' })
+      .set('x-talo-alias', String(player.aliases[0].id))
+      .set('x-talo-continuity-timestamp', String(continuityDate.getTime()))
+      .expect(200)
+
+    expect(new Date(res.body.entry.createdAt).getHours()).toBe(continuityDate.getHours())
+  })
 })

tests/services/_api/player-api/identify.test.ts

@@ -2,7 +2,7 @@ import { Collection, EntityManager } from '@mikro-orm/mysql'
 import request from 'supertest'
 import { APIKeyScope } from '../../../../src/entities/api-key'
 import PlayerFactory from '../../../fixtures/PlayerFactory'
-import { isToday } from 'date-fns'
+import { isToday, subHours } from 'date-fns'
 import PlayerGroupFactory from '../../../fixtures/PlayerGroupFactory'
 import PlayerGroupRule, { PlayerGroupRuleName, PlayerGroupRuleCastType } from '../../../../src/entities/player-group-rule'
 import PlayerProp from '../../../../src/entities/player-prop'
@@ -124,4 +124,20 @@ describe('Player API service - identify', () => {
 
     expect(res.body).toStrictEqual({ message: 'Player not found: Talo aliases must be created using the /v1/players/auth API' })
   })
+
+  it('should set the createdAt for the player and aliases to the continuity date', async () => {
+    const [, token] = await createAPIKeyAndToken([APIKeyScope.READ_PLAYERS, APIKeyScope.WRITE_PLAYERS])
+
+    const continuityDate = subHours(new Date(), 1)
+
+    const res = await request(global.app)
+      .get('/v1/players/identify')
+      .query({ service: 'steam', identifier: 'bizboz' })
+      .auth(token, { type: 'bearer' })
+      .set('x-talo-continuity-timestamp', String(continuityDate.getTime()))
+      .expect(200)
+
+    expect(res.body.alias.createdAt).toBe(continuityDate.toISOString())
+    expect(res.body.alias.player.createdAt).toBe(continuityDate.toISOString())
+  })
 })