daily rank

Author: fehmer

backend/__tests__/__integration__/utils/daily-leaderboards.spec.ts

@@ -311,12 +311,44 @@ describe("Daily Leaderboards", () => {
       it("gets rank", async () => {
         //GIVEN
         const user1 = await givenResult({ wpm: 50 });
-        const _user2 = await givenResult({ wpm: 60 });
+        const user2 = await givenResult({ wpm: 60 });
 
-        //WHEN
-        const rank = await lb.getRank(user1.uid, dailyLeaderboardsConfig);
-        //THEN
-        expect(rank).toEqual({ rank: 2, ...user1 });
+        //WHEN / THEN
+        expect(await lb.getRank(user1.uid, dailyLeaderboardsConfig)).toEqual({
+          rank: 2,
+          ...user1,
+        });
+        expect(await lb.getRank(user2.uid, dailyLeaderboardsConfig)).toEqual({
+          rank: 1,
+          ...user2,
+        });
+      });
+
+      it("should return null for unknown user", async () => {
+        expect(await lb.getRank("decoy", dailyLeaderboardsConfig)).toBeNull();
+        expect(
+          await lb.getRank("decoy", dailyLeaderboardsConfig, [
+            "unknown",
+            "unknown2",
+          ])
+        ).toBeNull();
+      });
+
+      it("gets rank for friends", async () => {
+        //GIVEN
+        const user1 = await givenResult({ wpm: 50 });
+        const user2 = await givenResult({ wpm: 60 });
+        const _user3 = await givenResult({ wpm: 70 });
+        const friends = [user1.uid, user2.uid, "decoy"];
+
+        //WHEN / THEN
+        expect(
+          await lb.getRank(user2.uid, dailyLeaderboardsConfig, friends)
+        ).toEqual({ rank: 1, ...user2 });
+
+        expect(
+          await lb.getRank(user1.uid, dailyLeaderboardsConfig, friends)
+        ).toEqual({ rank: 2, ...user1 });
       });
     });
 

backend/__tests__/api/controllers/leaderboard.spec.ts

@@ -294,9 +294,11 @@ describe("Loaderboard Controller", () => {
 
   describe("get rank", () => {
     const getLeaderboardRankMock = vi.spyOn(LeaderboardDal, "getRank");
+    const getFriendsUidsMock = vi.spyOn(FriendDal, "getFriendsUids");
 
     afterEach(() => {
       getLeaderboardRankMock.mockClear();
+      getFriendsUidsMock.mockClear();
     });
 
     it("fails withouth authentication", async () => {
@@ -308,7 +310,6 @@ describe("Loaderboard Controller", () => {
 
     it("should get for english time 60", async () => {
       //GIVEN
-
       const entryId = new ObjectId();
       const resultEntry = {
         _id: entryId,
@@ -323,7 +324,6 @@ describe("Loaderboard Controller", () => {
       getLeaderboardRankMock.mockResolvedValue(resultEntry);
 
       //WHEN
-
       const { body } = await mockApp
         .get("/leaderboards/rank")
         .query({ language: "english", mode: "time", mode2: "60" })
@@ -344,6 +344,37 @@ describe("Loaderboard Controller", () => {
         undefined
       );
     });
+
+    it("should get for english time 60 friends only", async () => {
+      //GIVEN
+      await enableFriendsFeature(true);
+      const friends = ["friendOne", "friendTwo"];
+      getFriendsUidsMock.mockResolvedValue(friends);
+      getLeaderboardRankMock.mockResolvedValue({} as any);
+
+      //WHEN
+      await mockApp
+        .get("/leaderboards/rank")
+        .query({
+          language: "english",
+          mode: "time",
+          mode2: "60",
+          friendsOnly: true,
+        })
+        .set("Authorization", `Bearer ${uid}`)
+        .expect(200);
+
+      //THEN
+      expect(getLeaderboardRankMock).toHaveBeenCalledWith(
+        "time",
+        "60",
+        "english",
+        uid,
+        friends
+      );
+      expect(getFriendsUidsMock).toHaveBeenCalledWith(uid);
+    });
+
     it("should get with ape key", async () => {
       await acceptApeKeys(true);
       const apeKey = await mockAuthenticateWithApeKey(uid, await configuration);
@@ -795,10 +826,12 @@ describe("Loaderboard Controller", () => {
     );
 
     const getRankMock = vi.fn();
+    const getFriendsUidsMock = vi.spyOn(FriendDal, "getFriendsUids");
 
     beforeEach(async () => {
       getDailyLeaderboardMock.mockClear();
       getRankMock.mockClear();
+      getFriendsUidsMock.mockClear();
 
       getDailyLeaderboardMock.mockReturnValue({
         getRank: getRankMock,
@@ -820,6 +853,7 @@ describe("Loaderboard Controller", () => {
         .query({ language: "english", mode: "time", mode2: "60" })
         .expect(401);
     });
+
     it("should get for english time 60", async () => {
       //GIVEN
       const lbConf = (await configuration).dailyLeaderboards;
@@ -862,8 +896,42 @@ describe("Loaderboard Controller", () => {
         -1
       );
 
-      expect(getRankMock).toHaveBeenCalledWith(uid, lbConf);
+      expect(getRankMock).toHaveBeenCalledWith(uid, lbConf, undefined);
     });
+
+    it("should get for english time 60 friends only", async () => {
+      //GIVEN
+      const lbConf = (await configuration).dailyLeaderboards;
+      getRankMock.mockResolvedValue({});
+      const friends = ["friendOne", "friendTwo"];
+      getFriendsUidsMock.mockResolvedValue(friends);
+
+      //WHEN
+      await mockApp
+        .get("/leaderboards/daily/rank")
+        .set("Authorization", `Bearer ${uid}`)
+        .query({
+          language: "english",
+          mode: "time",
+          mode2: "60",
+          friendsOnly: true,
+        })
+        .expect(200);
+
+      //THEN
+
+      expect(getDailyLeaderboardMock).toHaveBeenCalledWith(
+        "english",
+        "time",
+        "60",
+        lbConf,
+        -1
+      );
+
+      expect(getRankMock).toHaveBeenCalledWith(uid, lbConf, friends);
+      expect(getFriendsUidsMock).toHaveBeenCalledWith(uid);
+    });
+
     it("fails if daily leaderboards are disabled", async () => {
       await dailyLeaderboardEnabled(false);
 
@@ -876,6 +944,7 @@ describe("Loaderboard Controller", () => {
         "Daily leaderboards are not available at this time."
       );
     });
+
     it("should get for mode", async () => {
       for (const mode of ["time", "words", "quote", "zen", "custom"]) {
         const response = await mockApp
@@ -885,6 +954,7 @@ describe("Loaderboard Controller", () => {
         expect(response.status, "for mode " + mode).toEqual(200);
       }
     });
+
     it("should get for mode2", async () => {
       for (const mode2 of allModes) {
         const response = await mockApp

backend/redis-scripts/get-rank.lua

@@ -0,0 +1,54 @@
+-- Helper to split CSV string into a list
+local function split_csv(csv)
+    local result = {}
+    for user_id in string.gmatch(csv, '([^,]+)') do
+        table.insert(result, user_id)
+    end
+    return result
+end
+
+local redis_call = redis.call
+local leaderboard_scores_key, leaderboard_results_key = KEYS[1], KEYS[2]
+
+local user_id = ARGV[1]
+local include_scores = ARGV[2]
+local user_ids_csv = ARGV[3]
+
+local rank = nil
+local result = {}   
+local score = ''
+
+
+-- filtered leaderboard
+if user_ids_csv ~= "" then
+
+    local filtered_user_ids = split_csv(user_ids_csv)
+    local scored_users = {}
+    for _, user_id in ipairs(filtered_user_ids) do
+        local score = redis_call('ZSCORE', leaderboard_scores_key, user_id)
+        if score then
+            local number_score = tonumber(score)            
+            table.insert(scored_users, {user_id = user_id, score = number_score})
+        end
+    end
+    table.sort(scored_users, function(a, b) return a.score > b.score end)   
+
+    for i = 1, #scored_users do
+        if scored_users[i].user_id == user_id then
+            rank = i - 1
+        end
+    end
+
+else
+-- global leaderboarc
+    
+    rank = redis_call('ZREVRANK', leaderboard_scores_key, user_id)
+    
+end
+
+if (include_scores == "true") then
+    score = redis_call('ZSCORE', leaderboard_scores_key, user_id)
+end
+result = redis_call('HGET', leaderboard_results_key, user_id)
+
+return {rank, score, result}

backend/src/api/controllers/leaderboard.ts

@@ -171,7 +171,15 @@ export async function getDailyLeaderboard(
 export async function getDailyLeaderboardRank(
   req: MonkeyRequest<GetDailyLeaderboardRankQuery>
 ): Promise<GetLeaderboardDailyRankResponse> {
+  const { friendsOnly } = req.query;
   const { uid } = req.ctx.decodedToken;
+  const friendConfig = req.ctx.configuration.friends;
+
+  const friendUids = await getFriendsUids(
+    uid,
+    friendsOnly === true,
+    friendConfig
+  );
 
   const dailyLeaderboard = getDailyLeaderboardWithError(
     req.query,
@@ -180,7 +188,8 @@ export async function getDailyLeaderboardRank(
 
   const rank = await dailyLeaderboard.getRank(
     uid,
-    req.ctx.configuration.dailyLeaderboards
+    req.ctx.configuration.dailyLeaderboards,
+    friendUids
   );
 
   return new MonkeyResponse("Daily leaderboard rank retrieved", rank);

backend/src/init/redis.ts

@@ -36,6 +36,14 @@ export type RedisConnectionWithCustomMethods = Redis & {
     withScores: string,
     userIds: string
   ) => Promise<[string[], string[], string, string, string[]]>; //entries, scores(optional), count, min_score(optiona), ranks(optional)
+  getRank: (
+    keyCount: number,
+    scoresKey: string,
+    resultsKey: string,
+    uid: string,
+    withScores: string,
+    userIds: string
+  ) => Promise<[number, string, string]>; //rank, score(optional), entry json
   purgeResults: (
     keyCount: number,
     uid: string,

backend/src/utils/daily-leaderboards.ts

@@ -195,30 +195,30 @@ export class DailyLeaderboard {
 
   public async getRank(
     uid: string,
-    dailyLeaderboardsConfig: Configuration["dailyLeaderboards"]
+    dailyLeaderboardsConfig: Configuration["dailyLeaderboards"],
+    userIds?: string[]
   ): Promise<LeaderboardEntry | null> {
     const connection = RedisClient.getConnection();
     if (!connection || !dailyLeaderboardsConfig.enabled) {
       throw new Error("Redis connection is unavailable");
     }
+    if (userIds?.length === 0) {
+      return null;
+    }
 
     const { leaderboardScoresKey, leaderboardResultsKey } =
       this.getTodaysLeaderboardKeys();
 
-    const redisExecResult = (await connection
-      .multi()
-      .zrevrank(leaderboardScoresKey, uid)
-      .zcard(leaderboardScoresKey)
-      .hget(leaderboardResultsKey, uid)
-      .exec()) as [
-      [null, number | null],
-      [null, number | null],
-      [null, string | null]
-    ];
-
-    const [[, rank], [, _count], [, result]] = redisExecResult;
+    const [rank, _score, result] = await connection.getRank(
+      2,
+      leaderboardScoresKey,
+      leaderboardResultsKey,
+      uid,
+      "false",
+      userIds?.join(",") ?? ""
+    );
 
-    if (rank === null) {
+    if (rank === null || rank === undefined) {
       return null;
     }