fix: nearby still triggered if old location (e.g. 3 weeks ago)

Author: wsdt

backend/src/entities/user/user.repository.ts

@@ -7,6 +7,7 @@ import {
     EIntention,
     EVerificationStatus,
 } from "@/types/user.types";
+import { getNearbyMaxLocationAge } from "@/utils/date.utils";
 import { getTypedCoordinatesFromPoint } from "@/utils/location.utils";
 import { getAgeRangeParsed } from "@/utils/misc.utils";
 import { Injectable, Logger } from "@nestjs/common";
@@ -197,13 +198,12 @@ export class UserRepository extends Repository<User> {
     }
 
     private withRecentLocationsOnly(): this {
-        const h24HoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
         this.queryBuilder.andWhere(
             `
                 user.locationLastTimeUpdated IS NOT NULL 
                 AND user.locationLastTimeUpdated >= :h24HoursAgo
             `,
-            { h24HoursAgo },
+            { h24HoursAgo: getNearbyMaxLocationAge() },
         );
         return this;
     }

backend/src/entities/user/user.service.ts

@@ -24,6 +24,7 @@ import {
     ELanguage,
     EVerificationStatus,
 } from "@/types/user.types";
+import { getNearbyMaxLocationAge } from "@/utils/date.utils";
 import {
     API_VERSION,
     BE_ENDPOINT,
@@ -751,6 +752,13 @@ export class UserService {
             )
             .andWhere("user.location IS NOT NULL")
             .andWhere("user.isActive = :isActive", { isActive: true })
+            .andWhere(
+                `
+                user.locationLastTimeUpdated IS NOT NULL 
+                AND user.locationLastTimeUpdated >= :h24HoursAgo
+            `,
+                { h24HoursAgo: getNearbyMaxLocationAge() },
+            )
             .getRawMany();
 
         return result.map((row) => row.user_id);

backend/src/utils/date.utils.ts

@@ -1,5 +1,9 @@
 import { ELanguage } from "@/types/user.types";
 
+/** @dev Get current dateTime - 24h right now to define users as nearby right now */
+export const getNearbyMaxLocationAge = () =>
+    new Date(Date.now() - 24 * 60 * 60 * 1000);
+
 export const getAge = (birthday: Date | string): number => {
     const birthdayDate = new Date(birthday);
     const today = new Date();

backend/test/integration/services/user.service.spec.ts

@@ -1,3 +1,4 @@
+import { goBackInTimeFor } from "@/cronjobs/cronjobs.types";
 import { AppStatistic } from "@/entities/app-stats/app-stat.entity";
 import { EAPP_STAT_KEY } from "@/entities/app-stats/app-stats.types";
 import { Encounter } from "@/entities/encounter/encounter.entity";
@@ -462,6 +463,75 @@ describe("UserService", () => {
         }, 10000);
     });
 
+    describe("is nearby logic", () => {
+        it("should only define a user as nearby if the lastLocationDateTimeUpdated is not older than 24h", async () => {
+            const user1 = await userFactory.persistNewTestUser({
+                dateMode: EDateMode.LIVE,
+                location: new PointBuilder().build(600, 600),
+                locationLastTimeUpdated: goBackInTimeFor(23, "hours"),
+                gender: EGender.WOMAN,
+                genderDesire: [EGender.MAN],
+                intentions: [EIntention.RELATIONSHIP],
+                approachChoice: EApproachChoice.BOTH,
+            });
+            const user2 = await userFactory.persistNewTestUser({
+                dateMode: EDateMode.LIVE,
+                location: new PointBuilder().build(0, 0),
+                locationLastTimeUpdated: goBackInTimeFor(23, "hours"),
+                gender: EGender.WOMAN,
+                genderDesire: [EGender.MAN],
+                intentions: [EIntention.RELATIONSHIP],
+                approachChoice: EApproachChoice.BOTH,
+            });
+            const user3 = await userFactory.persistNewTestUser({
+                dateMode: EDateMode.LIVE,
+                location: new PointBuilder().build(0, 0),
+                locationLastTimeUpdated: goBackInTimeFor(25, "hours"),
+                gender: EGender.WOMAN,
+                genderDesire: [EGender.MAN],
+                intentions: [EIntention.RELATIONSHIP],
+                approachChoice: EApproachChoice.BOTH,
+            });
+            const user4 = await userFactory.persistNewTestUser({
+                dateMode: EDateMode.LIVE,
+                location: new PointBuilder().build(0, 0),
+                locationLastTimeUpdated: goBackInTimeFor(23, "hours"),
+                isActive: false,
+                gender: EGender.WOMAN,
+                genderDesire: [EGender.MAN],
+                intentions: [EIntention.RELATIONSHIP],
+                approachChoice: EApproachChoice.BOTH,
+            });
+            const user5 = await userFactory.persistNewTestUser({
+                dateMode: EDateMode.LIVE,
+                location: null,
+                locationLastTimeUpdated: goBackInTimeFor(23, "hours"),
+                gender: EGender.WOMAN,
+                genderDesire: [EGender.MAN],
+                intentions: [EIntention.RELATIONSHIP],
+                approachChoice: EApproachChoice.BOTH,
+            });
+
+            const userIds = [user1.id, user2.id, user3.id, user4.id, user5.id];
+            expect(userIds.length).toEqual(
+                (await userService.findAll()).length,
+            );
+
+            const nearbyUserIds = await userService.findUsersNearbyByUserIds(
+                userIds,
+                new PointBuilder().build(0, 0),
+                1500,
+            );
+            expect(nearbyUserIds.find((id) => id === user1.id)).toBeUndefined(); // @dev location wise not nearby
+            expect(nearbyUserIds.find((id) => id === user2.id)).toEqual(
+                user2.id,
+            ); // @dev location and time wise nearby
+            expect(nearbyUserIds.find((id) => id === user3.id)).toBeUndefined(); // @dev location wise nearby but location too old
+            expect(nearbyUserIds.find((id) => id === user4.id)).toBeUndefined(); // @dev nearby but account inactive
+            expect(nearbyUserIds.find((id) => id === user5.id)).toBeUndefined(); // @dev nearby but no location available
+        });
+    });
+
     describe("encounter lookup", function () {
         it("should not find matches if 2 people already met", async () => {
             const mainUser = await userFactory.persistNewTestUser({