8723713852

Committed 17 Apr 2024 02:27PM UTC coverage: 32.063% (+0.06%) from 32.005%

Build # 8723713852

Build Type

Pull #8980

github

Committed by

oetherington

Commit Message

Fix dependency cycle

Pull Request Pull Request #8980: Materialized view for BTREE login token lookup

Run Details

4663 of 37874 branches covered (12.31%)

Branch coverage included in aggregate %.

9 of 28 new or added lines in 6 files covered. (32.14%)

1 existing line in 1 file now uncovered.

27100 of 61191 relevant lines covered (44.29%)

183.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

18.64

/packages/lesswrong/server/repos/UsersRepo.ts

import AbstractRepo from "./AbstractRepo";
import Users from "../../lib/collections/users/collection";
import { UpvotedUser } from "../../components/users/DialogueMatchingPage";
import { calculateVotePower } from "../../lib/voting/voteTypes";
import { ActiveDialogueServer } from "../../components/hooks/useUnreadNotifications";
import { recordPerfMetrics } from "./perfMetricWrapper";
import { isEAForum } from "../../lib/instanceSettings";
import { getPostgresViewByName } from "../postgresView";

const GET_USERS_BY_EMAIL_QUERY = `
-- UsersRepo.GET_USERS_BY_EMAIL_QUERY 
SELECT *
FROM "Users"
WHERE LOWER(email) = LOWER($1)
UNION
SELECT *
FROM "Users"
WHERE _id IN (
  SELECT _id
  FROM "Users", UNNEST(emails) unnested
  WHERE UNNESTED->>'address' = $1
)`;

const GET_USER_BY_USERNAME_OR_EMAIL_QUERY = `
-- UsersRepo.GET_USER_BY_USERNAME_OR_EMAIL_QUERY
SELECT *
FROM "Users"
WHERE username = $1
UNION
SELECT *
FROM "Users"
WHERE LOWER(email) = LOWER($1)
UNION
SELECT *
FROM "Users"
WHERE _id IN (
  SELECT _id
  FROM "Users", UNNEST(emails) unnested
  WHERE UNNESTED->>'address' = $1
)
LIMIT 1
`;

export type MongoNearLocation = { type: "Point", coordinates: number[] }

class UsersRepo extends AbstractRepo<"Users"> {
  constructor() {
    super(Users);
  }

  getUserByLoginToken(hashedToken: string): Promise<DbUser | null> {
    return this.oneOrNone(`
      -- UsersRepo.getUserByLoginToken
      SELECT * FROM fm_get_user_by_login_token($1)
    `, [hashedToken]);
  }

  getUsersWhereLocationIsInNotificationRadius(location: MongoNearLocation): Promise<Array<DbUser>> {
    // the notification radius is in miles, so we convert the EARTH_DISTANCE from meters to miles
    return this.any(`
      -- UsersRepo.getUsersWhereLocationIsInNotificationRadius
      SELECT *
      FROM "Users"
      WHERE (
        EARTH_DISTANCE(
          LL_TO_EARTH(
            ("nearbyEventsNotificationsMongoLocation"->'coordinates'->0)::FLOAT8,
            ("nearbyEventsNotificationsMongoLocation"->'coordinates'->1)::FLOAT8
          ),
          LL_TO_EARTH($1, $2)
        ) * 0.000621371
      ) < "nearbyEventsNotificationsRadius"
    `, [location.coordinates[0], location.coordinates[1]])
  }

  getUserByEmail(email: string): Promise<DbUser | null> {
    return this.oneOrNone(`
      -- UsersRepo.getUserByEmail
      ${GET_USERS_BY_EMAIL_QUERY}
      LIMIT 1
    `, [email]);
  }

  getAllUsersByEmail(email: string): Promise<DbUser[]> {
    return this.any(GET_USERS_BY_EMAIL_QUERY, [email]);
  }

  getUserByUsernameOrEmail(usernameOrEmail: string): Promise<DbUser | null> {
    return this.oneOrNone(GET_USER_BY_USERNAME_OR_EMAIL_QUERY, [usernameOrEmail]);
  }

  async clearLoginTokens(userId: string): Promise<void> {
    await this.none(`
      -- UsersRepo.clearLoginTokens
      UPDATE "Users"
      SET services = jsonb_set(
        services,
        '{resume, loginTokens}'::TEXT[],
        '[]'::JSONB,
        true
      )
      WHERE _id = $1
    `, [userId]);
    await this.refreshUserLoginTokens();
  }

  async resetPassword(userId: string, hashedPassword: string): Promise<void> {
    await this.none(`
      -- UsersRepo.resetPassword
      UPDATE "Users"
      SET services = jsonb_set(
        CASE WHEN services -> 'password' IS NULL THEN
          jsonb_set(
            COALESCE(services, '{}'::JSONB),
            '{password}'::TEXT[],
            jsonb_build_object('bcrypt', $2),
            true
          )
        ELSE
          jsonb_set(
            services,
            '{password, bcrypt}'::TEXT[],
            to_jsonb($2::TEXT),
            true
          )
        END,
        '{resume, loginTokens}'::TEXT[],
        '[]'::JSONB,
        true
      )
      WHERE _id = $1
    `, [userId, hashedPassword]);
    await this.refreshUserLoginTokens();
  }

  private async refreshUserLoginTokens() {
    await getPostgresViewByName("UserLoginTokens").refresh(this.getRawDb());
  }

  verifyEmail(userId: string): Promise<null> {
    return this.none(`
      -- UsersRepo.verifyEmail
      UPDATE "Users"
      SET emails[1] = jsonb_set(emails[1], '{verified}', 'true'::JSONB, true)
      WHERE _id = $1
    `, [userId]);
  }

  setExpandFrontpageSection(userId: string, section: string, expanded: boolean): Promise<null> {
    return this.none(`
      -- UsersRepo.setExpandFrontpageSection
      UPDATE "Users"
      SET "expandedFrontpageSections" =
        COALESCE("expandedFrontpageSections", '{}'::JSONB) ||
          fm_build_nested_jsonb(('{' || $2 || '}')::TEXT[], $3::JSONB)
      WHERE "_id" = $1
    `, [userId, section, String(expanded)]);
  }

  removeAlignmentGroupAndKarma(userId: string, reduceAFKarma: number): Promise<null> {
    return this.none(`
      -- UsersRepo.removeAlignmentGroupAndKarma
      UPDATE "Users"
      SET
        "groups" = array_remove("groups", 'alignmentVoters'),
        "afKarma" = "afKarma" - $2
      WHERE _id = $1
    `, [userId, reduceAFKarma]);
  }

  private getSearchDocumentQuery(): string {
    return `
      -- UsersRepo.getSearchDocumentQuery
      SELECT
        u."_id",
        u."_id" AS "objectID",
        u."username",
        u."displayName",
        u."createdAt",
        EXTRACT(EPOCH FROM u."createdAt") * 1000 AS "publicDateMs",
        COALESCE(u."isAdmin", FALSE) AS "isAdmin",
        COALESCE(u."deleted", FALSE) AS "deleted",
        COALESCE(u."deleteContent", FALSE) AS "deleteContent",
        u."profileImageId",
        u."biography"->>'html' AS "bio",
        u."howOthersCanHelpMe"->>'html' AS "howOthersCanHelpMe",
        u."howICanHelpOthers"->>'html' AS "howICanHelpOthers",
        COALESCE(u."karma", 0) AS "karma",
        u."slug",
        u."jobTitle",
        u."organization",
        u."careerStage",
        u."website",
        u."groups",
        u."groups" @> ARRAY['alignmentForum'] AS "af",
        u."profileTagIds" AS "tags",
        CASE WHEN u."mapLocation"->'geometry'->'location' IS NULL THEN NULL ELSE
          JSONB_BUILD_OBJECT(
            'type', 'point',
            'coordinates', JSONB_BUILD_ARRAY(
              u."mapLocation"->'geometry'->'location'->'lng',
              u."mapLocation"->'geometry'->'location'->'lat'
          )) END AS "_geoloc",
        u."mapLocation"->'formatted_address' AS "mapLocationAddress",
        NOW() AS "exportedAt"
      FROM "Users" u
    `;
  }

  getSearchDocumentById(id: string): Promise<SearchUser> {
    return this.getRawDb().one(`
      -- UsersRepo.getSearchDocumentById
      ${this.getSearchDocumentQuery()}
      WHERE u."_id" = $1
    `, [id]);
  }

  getSearchDocuments(limit: number, offset: number): Promise<SearchUser[]> {
    return this.getRawDb().any(`
      -- UsersRepo.getSearchDocuments
      ${this.getSearchDocumentQuery()}
      WHERE u."displayName" IS NOT NULL
      ORDER BY u."createdAt" DESC
      LIMIT $1
      OFFSET $2
    `, [limit, offset]);
  }

  async countSearchDocuments(): Promise<number> {
    const {count} = await this.getRawDb().one(`
      -- UsersRepo.countSearchDocuments
      SELECT COUNT(*) FROM "Users"
    `);
    return count;
  }
  
  async getRandomActiveUser(): Promise<DbUser> {
    return this.one(`
      -- UsersRepo.getRandomActiveUser
      SELECT u.*
      FROM "Users" u
      JOIN (
        SELECT "userId", MAX("lastUpdated") AS max_last_updated
        FROM "ReadStatuses"
        GROUP BY "userId"
      ) rs
      ON rs."userId" = u."_id"
      WHERE COALESCE(u."deleted", FALSE) = FALSE
      AND rs.max_last_updated > NOW() - INTERVAL '1 month'
      ORDER BY RANDOM()
      LIMIT 1;
    `);
  }
  
  async getRandomActiveAuthor(): Promise<DbUser> {
    return this.one(`
      -- UsersRepo.getRandomActiveAuthor
      SELECT u.*
      FROM "Users" u
      JOIN (
        SELECT "userId", MAX("createdAt") AS max_created_at
        FROM "Comments"
        GROUP BY "userId"
      ) c
      ON c."userId" = u."_id"
      JOIN (
        SELECT "userId", MAX("postedAt") AS max_posted_at
        FROM "Posts"
        GROUP BY "userId"
      ) p
      ON p."userId" = u."_id"
      WHERE COALESCE(u."deleted", FALSE) = FALSE
      AND (c.max_created_at > NOW() - INTERVAL '1 month' OR p.max_posted_at > NOW() - INTERVAL '1 month')
      ORDER BY RANDOM()
      LIMIT 1;
    `);
  }

  async getUsersWhoHaveMadeDialogues(): Promise<DbUser[]> {
    return this.getRawDb().any(`
      -- UsersRepo.getUsersWhoHaveMadeDialogues
      WITH all_dialogue_authors AS
        (SELECT (UNNESTED->>'userId') AS _id
            FROM "Posts" p, UNNEST("coauthorStatuses") unnested
            WHERE p."collabEditorDialogue" IS TRUE 
            AND p."draft" IS FALSE
        UNION
        SELECT p."userId" as _id
            FROM "Posts" p
            WHERE p."collabEditorDialogue" IS TRUE
            AND p."draft" IS FALSE
        )
      SELECT u.*
      FROM "Users" u
      INNER JOIN all_dialogue_authors ON all_dialogue_authors._id = u._id
    `)
  }

  async getUsersWhoHaveOptedInToDialogueFacilitation(): Promise<DbUser[]> {
    return this.getRawDb().any(`
        -- UsersRepo.getUsersWhoHaveOptedInToDialogueFacilitation
        SELECT *
        FROM "Users" u
        WHERE u."optedInToDialogueFacilitation" IS TRUE
    `)
  }  

  async getUsersWithNewDialogueChecks(): Promise<DbUser[]> {
    return this.manyOrNone(`
      -- UsersRepo.getUsersWithNewDialogueChecks
      SELECT DISTINCT ON ("Users"._id) "Users".*
      FROM "Users"
      INNER JOIN "DialogueChecks" ON "Users"._id = "DialogueChecks"."targetUserId"
      WHERE
          "DialogueChecks".checked IS TRUE
          AND NOT EXISTS (
              SELECT 1
              FROM "DialogueChecks" AS dc
              WHERE
                  "DialogueChecks"."userId" = dc."targetUserId"
                  AND "DialogueChecks"."targetUserId" = dc."userId"
                  AND dc.checked IS TRUE
          )
          AND (
              "DialogueChecks"."checkedAt" > COALESCE((
                  SELECT MAX("checkedAt")
                  FROM "DialogueChecks"
                  WHERE "DialogueChecks"."userId" = "Users"._id
              ), '1970-01-01')
          )
          AND (
              "DialogueChecks"."checkedAt" > NOW() - INTERVAL '1 week'
              OR
              NOT EXISTS (
                  SELECT 1
                  FROM "Notifications"
                  WHERE
                      "userId" = "Users"._id
                      AND type = 'newDialogueChecks'
              )
          )
          AND (
            NOW() - INTERVAL '1 week' > COALESCE((
              SELECT MAX("createdAt")
              FROM "Notifications"
              WHERE
                "userId" = "Users"._id
                AND type = 'newDialogueChecks'
            ), '1970-01-01')
        )
    `)
  }

  async getUsersTopUpvotedUsers(user: DbUser, limit = 20, recencyLimitDays = 10): Promise<UpvotedUser[]> {
    const karma = user?.karma ?? 0
    const smallVotePower = calculateVotePower(karma, "smallUpvote");
    const bigVotePower = calculateVotePower(karma, "bigUpvote");
    
    return this.getRawDb().any(`
      -- UsersRepo.getUsersTopUpvotedUsers
      WITH "CombinedVotes" AS (
      -- Joining Users with Posts and Votes
      SELECT
          v.power AS vote_power,
          u._id AS user_id,
          u.username AS user_username,
          u."displayName" AS user_displayName,
          CASE
              WHEN v."extendedVoteType"->>'agreement' = 'bigDownvote' THEN -$3
              WHEN v."extendedVoteType"->>'agreement' = 'smallDownvote' THEN -$2
              WHEN v."extendedVoteType"->>'agreement' = 'neutral' THEN 0
              WHEN v."extendedVoteType"->>'agreement' = 'smallUpvote' THEN $2
              WHEN v."extendedVoteType"->>'agreement' = 'bigUpvote' THEN $3
              ELSE 0
          END AS agreement_value
        FROM "Users" u
        INNER JOIN "Posts" p ON u._id = p."userId"
        INNER JOIN "Votes" v ON p._id = v."documentId"
        WHERE
            v."userId" = $1
            AND u._id != $1
            AND v."votedAt" > NOW() - INTERVAL '1.5 years'
            AND v."cancelled" IS NOT TRUE

        UNION ALL
    
        -- Joining Users with Comments and Votes
        SELECT
            v.power AS vote_power,
            u._id AS user_id,
            u.username AS user_username,
            u."displayName" AS user_displayName,
            CASE
                WHEN v."extendedVoteType"->>'agreement' = 'bigDownvote' THEN -$3
                WHEN v."extendedVoteType"->>'agreement' = 'smallDownvote' THEN -$2
                WHEN v."extendedVoteType"->>'agreement' = 'neutral' THEN 0
                WHEN v."extendedVoteType"->>'agreement' = 'smallUpvote' THEN $2
                WHEN v."extendedVoteType"->>'agreement' = 'bigUpvote' THEN $3
                ELSE 0
            END AS agreement_value
        FROM "Users" u
        INNER JOIN "Comments" c ON u._id = c."userId"
        INNER JOIN "Votes" v ON c._id = v."documentId"
        WHERE
            v."userId" = $1
            AND u._id != $1
            AND v."votedAt" > NOW() - INTERVAL '1.5 years'
            AND v."cancelled" IS NOT TRUE
    ),

    "UserChecks" AS (
      SELECT
          u._id,
          COALESCE(
              EXISTS (
                  SELECT 1
                  FROM "DialogueChecks" as dc
                  WHERE
                      dc."userId" = u._id
                      AND "checkedAt" > NOW() - INTERVAL '$5 days'
              ),
              FALSE
          ) AS recently_active_matchmaking
      FROM "Users" as u
    )
  
    SELECT
      user_id AS _id,
      user_username AS username,
      user_displayName AS "displayName",
      SUM(vote_power) AS total_power,
      ARRAY_AGG(vote_power) AS power_values,
      COUNT(vote_power) AS vote_counts,
      SUM(agreement_value) AS total_agreement,
      ARRAY(
          SELECT val
          FROM UNNEST(ARRAY_AGG(agreement_value)) AS val
          WHERE val != 0
      ) AS agreement_values,
      uc.recently_active_matchmaking
    FROM "CombinedVotes" as cv
    LEFT JOIN "UserChecks" AS uc ON cv.user_id = uc._id
    GROUP BY 
      user_id, 
      user_username, 
      user_displayName,
      uc.recently_active_matchmaking
    HAVING SUM(vote_power) > 1
    ORDER BY total_power DESC
    LIMIT $4;
      `, [user._id, smallVotePower, bigVotePower, limit, recencyLimitDays])
  }

  async getDialogueMatchedUsers(userId: string): Promise<DbUser[]> {
    return this.any(`
      -- UsersRepo.getDialogueMatchedUsers
      SELECT DISTINCT(u.*)
      FROM "DialogueChecks" other_users_checks
      JOIN "DialogueChecks" current_user_checks
      -- Join such that there must exist reciprocal checks
      ON (
        other_users_checks."targetUserId" = current_user_checks."userId"
        AND current_user_checks."targetUserId" = other_users_checks."userId"
        AND other_users_checks.checked IS TRUE
        AND current_user_checks.checked IS TRUE
      )
      JOIN "Users" u
      -- Given those, join for users who've created checks on you
      ON (
        other_users_checks."userId" = u._id
        AND other_users_checks."targetUserId" = $1
        AND current_user_checks."userId" = $1
      )
    `, [userId]);
  }

  async getDialogueRecommendedUsers(userId: string, upvotedUsers: UpvotedUser[], limit = 100): Promise<DbUser[]> {
    const upvotedUserIds = upvotedUsers.map(user => user._id);

    return this.any(`
    -- UsersRepo.getDialogueRecommendedUsers
    (
      SELECT u.*
      FROM unnest($2::text[]) AS uv(_id)
      INNER JOIN "Users" AS u ON uv._id = u._id
      WHERE
      -- Exclude users that the current user has already checked

        (
          SELECT COUNT(*)
          FROM "DialogueChecks"
          WHERE "userId" = $1 AND "targetUserId" = uv._id AND ("checked" IS TRUE OR "hideInRecommendations" IS TRUE)
        ) = 0
        AND
        (
          -- Don't recommend users who've never commented on your posts

          (
            SELECT COUNT(*)
            FROM public."Comments" AS c
            INNER JOIN "Posts" AS p ON c."postId" = p._id
            WHERE c."userId" = uv._id AND p."userId" = $1
          ) >= 1
          OR 
          -- Don't recommend users who've never replied to your comments 

          (
            SELECT COUNT(*)
            FROM public."Comments"
            WHERE
              "userId" = uv._id
              AND "parentCommentId" IN (
                SELECT _id
                FROM "Comments"
                WHERE "userId" = $1
              )
          ) >= 1
        )
      LIMIT $3
    )
    -- If the above query doesn't return enough users, then fill in the rest with users who you've upvoted
      UNION
      (
        SELECT u.*
        FROM unnest($2::text[]) AS uv(_id)
        INNER JOIN "Users" AS u ON uv._id = u._id
        WHERE
          (
            SELECT COUNT(*)
            FROM "DialogueChecks"
            WHERE "userId" = $1 AND "targetUserId" = uv._id AND ("checked" IS TRUE OR "hideInRecommendations" IS TRUE)
          ) = 0
        LIMIT $3
      )
    `, [userId, upvotedUserIds, limit]);
  }

  async getActiveDialogueMatchSeekers(limit: number): Promise<DbUser[]> {
    return this.manyOrNone(`
      -- UsersRepo.getActiveDialogueMatchSeekers
      SELECT  
        u.*,
        MAX(dc."checkedAt") AS "mostRecentCheckedAt"
      FROM public."Users" AS u
      LEFT JOIN public."DialogueChecks" AS dc ON u._id = dc."userId"
      WHERE dc."userId" IS NOT NULL
      GROUP BY u._id
      ORDER BY "mostRecentCheckedAt" DESC
      LIMIT $1;
    `, [limit])
  }

  async getActiveDialogues(userIds: string[]): Promise<ActiveDialogueServer[]> {
    const result = await this.getRawDb().any(`
    SELECT
        p._id,
        p.title,
        p."userId",
        p."coauthorStatuses",
        ARRAY_AGG(DISTINCT s."userId") AS "activeUserIds",
        MAX(r."editedAt") AS "mostRecentEditedAt"
    FROM "Posts" AS p
    INNER JOIN "Revisions" AS r ON p._id = r."documentId"
    INNER JOIN "CkEditorUserSessions" AS s ON p._id = s."documentId",
        unnest(p."coauthorStatuses") AS coauthors
    WHERE
        (
            coauthors ->> 'userId' = any($1)
            OR p."userId" = any($1)
        )
        AND s."endedAt" IS NULL
        AND (
          s."createdAt" > CURRENT_TIMESTAMP - INTERVAL '30 minutes'
          OR r."editedAt" > CURRENT_TIMESTAMP - INTERVAL '30 minutes'
        )
    GROUP BY p._id
    `, [userIds]);
  
    return result;
  }

  async isDisplayNameTaken(displayName: string): Promise<boolean> {
    const result = await this.getRawDb().one(`
      -- UsersRepo.isDisplayNameTaken
      SELECT COUNT(*) > 0 AS "isDisplayNameTaken"
      FROM "Users"
      WHERE "displayName" = $1
    `, [displayName]);
    return result.isDisplayNameTaken;
  }
  
  /**
   * Returns a list of users who haven't read a post in over 4 months
   * and who we want to email a feedback survey to.
   *
   * This excludes admins, deleted/deactivated users,
   * flagged or purged or removed from queue users,
   * users who were banned any time over the past 4 month period,
   * and users who have already been sent this email.
   */
  async getInactiveUsersToEmail(limit: number): Promise<DbUser[]> {
    return this.manyOrNone(`
      -- UsersRepo.getInactiveUsersToEmail
      SELECT
        u.*
      FROM public."Users" AS u
      LEFT JOIN (
        SELECT "userId", MAX("lastUpdated") AS max_last_updated
        FROM "ReadStatuses"
        WHERE "isRead" IS TRUE
        GROUP BY "userId"
      ) AS rs ON u._id = rs."userId"
      WHERE
        u."inactiveSurveyEmailSentAt" IS NULL
        AND u."unsubscribeFromAll" IS NOT TRUE
        AND u."isAdmin" IS NOT TRUE
        AND u.deleted IS NOT TRUE
        AND u."deleteContent" IS NOT TRUE
        AND u."sunshineFlagged" IS NOT TRUE
        AND (
          u.banned IS NULL
          OR u.banned < CURRENT_TIMESTAMP - INTERVAL '4 months'
        )
        AND (
          u."reviewedByUserId" IS NOT NULL
          OR u."sunshineNotes" IS NULL
          OR u."sunshineNotes" = ''
        )
        AND (
          (
            rs.max_last_updated IS NULL
            AND u."createdAt" < CURRENT_TIMESTAMP - INTERVAL '4 months'
          )
          OR (
            rs.max_last_updated IS NOT NULL
            AND rs.max_last_updated < CURRENT_TIMESTAMP - INTERVAL '4 months'
          )
        )
      ORDER BY u."createdAt" desc
      LIMIT $1;
    `, [limit])
  }

  async getCurationSubscribedUserIds(): Promise<string[]> {
    const verifiedEmailFilter = !isEAForum ? 'AND fm_has_verified_email(emails)' : '';

    const userIdRecords = await this.getRawDb().any<Record<'_id', string>>(`
      SELECT _id
      FROM "Users"
      WHERE "emailSubscribedToCurated" IS TRUE
        AND "deleted" IS NOT TRUE
        AND "email" IS NOT NULL
        AND "unsubscribeFromAll" IS NOT TRUE
        ${verifiedEmailFilter}
    `);

    return userIdRecords.map(({ _id }) => _id);
  }
}

recordPerfMetrics(UsersRepo, { excludeMethods: ['getUserByLoginToken'] });

export default UsersRepo;

1	import AbstractRepo from "./AbstractRepo";	1,716✔
2	import Users from "../../lib/collections/users/collection";	19✔
3	import { UpvotedUser } from "../../components/users/DialogueMatchingPage";
4	import { calculateVotePower } from "../../lib/voting/voteTypes";	19✔
5	import { ActiveDialogueServer } from "../../components/hooks/useUnreadNotifications";
6	import { recordPerfMetrics } from "./perfMetricWrapper";	19✔
7	import { isEAForum } from "../../lib/instanceSettings";	19✔
8	import { getPostgresViewByName } from "../postgresView";	19✔
9
10	const GET_USERS_BY_EMAIL_QUERY = `	19✔
11	-- UsersRepo.GET_USERS_BY_EMAIL_QUERY
12	SELECT *
13	FROM "Users"
14	WHERE LOWER(email) = LOWER($1)
15	UNION
16	SELECT *
17	FROM "Users"
18	WHERE _id IN (
19	SELECT _id
20	FROM "Users", UNNEST(emails) unnested
21	WHERE UNNESTED->>'address' = $1
22	)`;
23
24	const GET_USER_BY_USERNAME_OR_EMAIL_QUERY = `	19✔
25	-- UsersRepo.GET_USER_BY_USERNAME_OR_EMAIL_QUERY
26	SELECT *
27	FROM "Users"
28	WHERE username = $1
29	UNION
30	SELECT *
31	FROM "Users"
32	WHERE LOWER(email) = LOWER($1)
33	UNION
34	SELECT *
35	FROM "Users"
36	WHERE _id IN (
37	SELECT _id
38	FROM "Users", UNNEST(emails) unnested
39	WHERE UNNESTED->>'address' = $1
40	)
41	LIMIT 1
42	`;
43
44	export type MongoNearLocation = { type: "Point", coordinates: number[] }
45
46	class UsersRepo extends AbstractRepo<"Users"> {
47	constructor() {
48	super(Users);	1,659✔
49	}
50
51	getUserByLoginToken(hashedToken: string): Promise<DbUser \| null> {
52	return this.oneOrNone(`	×
53	-- UsersRepo.getUserByLoginToken
54	SELECT * FROM fm_get_user_by_login_token($1)
55	`, [hashedToken]);
56	}
57
58	getUsersWhereLocationIsInNotificationRadius(location: MongoNearLocation): Promise<Array<DbUser>> {
59	// the notification radius is in miles, so we convert the EARTH_DISTANCE from meters to miles
60	return this.any(`	×
61	-- UsersRepo.getUsersWhereLocationIsInNotificationRadius
62	SELECT *
63	FROM "Users"
64	WHERE (
65	EARTH_DISTANCE(
66	LL_TO_EARTH(
67	("nearbyEventsNotificationsMongoLocation"->'coordinates'->0)::FLOAT8,
68	("nearbyEventsNotificationsMongoLocation"->'coordinates'->1)::FLOAT8
69	),
70	LL_TO_EARTH($1, $2)
71	) * 0.000621371
72	) < "nearbyEventsNotificationsRadius"
73	`, [location.coordinates[0], location.coordinates[1]])
74	}
75
76	getUserByEmail(email: string): Promise<DbUser \| null> {
77	return this.oneOrNone(`	×
78	-- UsersRepo.getUserByEmail
79	${GET_USERS_BY_EMAIL_QUERY}
80	LIMIT 1
81	`, [email]);
82	}
83
84	getAllUsersByEmail(email: string): Promise<DbUser[]> {
85	return this.any(GET_USERS_BY_EMAIL_QUERY, [email]);	×
86	}
87
88	getUserByUsernameOrEmail(usernameOrEmail: string): Promise<DbUser \| null> {
89	return this.oneOrNone(GET_USER_BY_USERNAME_OR_EMAIL_QUERY, [usernameOrEmail]);	×
90	}
91
92	async clearLoginTokens(userId: string): Promise<void> {
NEW 93	await this.none(`	×
94	-- UsersRepo.clearLoginTokens
95	UPDATE "Users"
96	SET services = jsonb_set(
97	services,
98	'{resume, loginTokens}'::TEXT[],
99	'[]'::JSONB,
100	true
101	)
102	WHERE _id = $1
103	`, [userId]);
NEW 104	await this.refreshUserLoginTokens();	×
105	}
106
107	async resetPassword(userId: string, hashedPassword: string): Promise<void> {
NEW 108	await this.none(`	×
109	-- UsersRepo.resetPassword
110	UPDATE "Users"
111	SET services = jsonb_set(
112	CASE WHEN services -> 'password' IS NULL THEN
113	jsonb_set(
114	COALESCE(services, '{}'::JSONB),
115	'{password}'::TEXT[],
116	jsonb_build_object('bcrypt', $2),
117	true
118	)
119	ELSE
120	jsonb_set(
121	services,
122	'{password, bcrypt}'::TEXT[],
123	to_jsonb($2::TEXT),
124	true
125	)
126	END,
127	'{resume, loginTokens}'::TEXT[],
128	'[]'::JSONB,
129	true
130	)
131	WHERE _id = $1
132	`, [userId, hashedPassword]);
NEW 133	await this.refreshUserLoginTokens();	×
134	}
135
136	private async refreshUserLoginTokens() {
NEW 137	await getPostgresViewByName("UserLoginTokens").refresh(this.getRawDb());	×
138	}
139
140	verifyEmail(userId: string): Promise<null> {
141	return this.none(`	×
142	-- UsersRepo.verifyEmail
143	UPDATE "Users"
144	SET emails[1] = jsonb_set(emails[1], '{verified}', 'true'::JSONB, true)
145	WHERE _id = $1
146	`, [userId]);
147	}
148
149	setExpandFrontpageSection(userId: string, section: string, expanded: boolean): Promise<null> {
150	return this.none(`	×
151	-- UsersRepo.setExpandFrontpageSection
152	UPDATE "Users"
153	SET "expandedFrontpageSections" =
154	COALESCE("expandedFrontpageSections", '{}'::JSONB) \|\|
155	fm_build_nested_jsonb(('{' \|\| $2 \|\| '}')::TEXT[], $3::JSONB)
156	WHERE "_id" = $1
157	`, [userId, section, String(expanded)]);
158	}
159
160	removeAlignmentGroupAndKarma(userId: string, reduceAFKarma: number): Promise<null> {
161	return this.none(`	×
162	-- UsersRepo.removeAlignmentGroupAndKarma
163	UPDATE "Users"
164	SET
165	"groups" = array_remove("groups", 'alignmentVoters'),
166	"afKarma" = "afKarma" - $2
167	WHERE _id = $1
168	`, [userId, reduceAFKarma]);
169	}
170
171	private getSearchDocumentQuery(): string {
172	return `	×
173	-- UsersRepo.getSearchDocumentQuery
174	SELECT
175	u."_id",
176	u."_id" AS "objectID",
177	u."username",
178	u."displayName",
179	u."createdAt",
180	EXTRACT(EPOCH FROM u."createdAt") * 1000 AS "publicDateMs",
181	COALESCE(u."isAdmin", FALSE) AS "isAdmin",
182	COALESCE(u."deleted", FALSE) AS "deleted",
183	COALESCE(u."deleteContent", FALSE) AS "deleteContent",
184	u."profileImageId",
185	u."biography"->>'html' AS "bio",
186	u."howOthersCanHelpMe"->>'html' AS "howOthersCanHelpMe",
187	u."howICanHelpOthers"->>'html' AS "howICanHelpOthers",
188	COALESCE(u."karma", 0) AS "karma",
189	u."slug",
190	u."jobTitle",
191	u."organization",
192	u."careerStage",
193	u."website",
194	u."groups",
195	u."groups" @> ARRAY['alignmentForum'] AS "af",
196	u."profileTagIds" AS "tags",
197	CASE WHEN u."mapLocation"->'geometry'->'location' IS NULL THEN NULL ELSE
198	JSONB_BUILD_OBJECT(
199	'type', 'point',
200	'coordinates', JSONB_BUILD_ARRAY(
201	u."mapLocation"->'geometry'->'location'->'lng',
202	u."mapLocation"->'geometry'->'location'->'lat'
203	)) END AS "_geoloc",
204	u."mapLocation"->'formatted_address' AS "mapLocationAddress",
205	NOW() AS "exportedAt"
206	FROM "Users" u
207	`;
208	}
209
210	getSearchDocumentById(id: string): Promise<SearchUser> {
211	return this.getRawDb().one(`	×
212	-- UsersRepo.getSearchDocumentById
213	${this.getSearchDocumentQuery()}
214	WHERE u."_id" = $1
215	`, [id]);
216	}
217
218	getSearchDocuments(limit: number, offset: number): Promise<SearchUser[]> {
219	return this.getRawDb().any(`	×
220	-- UsersRepo.getSearchDocuments
221	${this.getSearchDocumentQuery()}
222	WHERE u."displayName" IS NOT NULL
223	ORDER BY u."createdAt" DESC
224	LIMIT $1
225	OFFSET $2
226	`, [limit, offset]);
227	}
228
229	async countSearchDocuments(): Promise<number> {
230	const {count} = await this.getRawDb().one(`	×
231	-- UsersRepo.countSearchDocuments
232	SELECT COUNT(*) FROM "Users"
233	`);
234	return count;	×
235	}
236
237	async getRandomActiveUser(): Promise<DbUser> {
238	return this.one(`	×
239	-- UsersRepo.getRandomActiveUser
240	SELECT u.*
241	FROM "Users" u
242	JOIN (
243	SELECT "userId", MAX("lastUpdated") AS max_last_updated
244	FROM "ReadStatuses"
245	GROUP BY "userId"
246	) rs
247	ON rs."userId" = u."_id"
248	WHERE COALESCE(u."deleted", FALSE) = FALSE
249	AND rs.max_last_updated > NOW() - INTERVAL '1 month'
250	ORDER BY RANDOM()
251	LIMIT 1;
252	`);
253	}
254
255	async getRandomActiveAuthor(): Promise<DbUser> {
256	return this.one(`	×
257	-- UsersRepo.getRandomActiveAuthor
258	SELECT u.*
259	FROM "Users" u
260	JOIN (
261	SELECT "userId", MAX("createdAt") AS max_created_at
262	FROM "Comments"
263	GROUP BY "userId"
264	) c
265	ON c."userId" = u."_id"
266	JOIN (
267	SELECT "userId", MAX("postedAt") AS max_posted_at
268	FROM "Posts"
269	GROUP BY "userId"
270	) p
271	ON p."userId" = u."_id"
272	WHERE COALESCE(u."deleted", FALSE) = FALSE
273	AND (c.max_created_at > NOW() - INTERVAL '1 month' OR p.max_posted_at > NOW() - INTERVAL '1 month')
274	ORDER BY RANDOM()
275	LIMIT 1;
276	`);
277	}
278
279	async getUsersWhoHaveMadeDialogues(): Promise<DbUser[]> {
280	return this.getRawDb().any(`	×
281	-- UsersRepo.getUsersWhoHaveMadeDialogues
282	WITH all_dialogue_authors AS
283	(SELECT (UNNESTED->>'userId') AS _id
284	FROM "Posts" p, UNNEST("coauthorStatuses") unnested
285	WHERE p."collabEditorDialogue" IS TRUE
286	AND p."draft" IS FALSE
287	UNION
288	SELECT p."userId" as _id
289	FROM "Posts" p
290	WHERE p."collabEditorDialogue" IS TRUE
291	AND p."draft" IS FALSE
292	)
293	SELECT u.*
294	FROM "Users" u
295	INNER JOIN all_dialogue_authors ON all_dialogue_authors._id = u._id
296	`)
297	}
298
299	async getUsersWhoHaveOptedInToDialogueFacilitation(): Promise<DbUser[]> {
300	return this.getRawDb().any(`	×
301	-- UsersRepo.getUsersWhoHaveOptedInToDialogueFacilitation
302	SELECT *
303	FROM "Users" u
304	WHERE u."optedInToDialogueFacilitation" IS TRUE
305	`)
306	}
307
308	async getUsersWithNewDialogueChecks(): Promise<DbUser[]> {
309	return this.manyOrNone(`	×
310	-- UsersRepo.getUsersWithNewDialogueChecks
311	SELECT DISTINCT ON ("Users"._id) "Users".*
312	FROM "Users"
313	INNER JOIN "DialogueChecks" ON "Users"._id = "DialogueChecks"."targetUserId"
314	WHERE
315	"DialogueChecks".checked IS TRUE
316	AND NOT EXISTS (
317	SELECT 1
318	FROM "DialogueChecks" AS dc
319	WHERE
320	"DialogueChecks"."userId" = dc."targetUserId"
321	AND "DialogueChecks"."targetUserId" = dc."userId"
322	AND dc.checked IS TRUE
323	)
324	AND (
325	"DialogueChecks"."checkedAt" > COALESCE((
326	SELECT MAX("checkedAt")
327	FROM "DialogueChecks"
328	WHERE "DialogueChecks"."userId" = "Users"._id
329	), '1970-01-01')
330	)
331	AND (
332	"DialogueChecks"."checkedAt" > NOW() - INTERVAL '1 week'
333	OR
334	NOT EXISTS (
335	SELECT 1
336	FROM "Notifications"
337	WHERE
338	"userId" = "Users"._id
339	AND type = 'newDialogueChecks'
340	)
341	)
342	AND (
343	NOW() - INTERVAL '1 week' > COALESCE((
344	SELECT MAX("createdAt")
345	FROM "Notifications"
346	WHERE
347	"userId" = "Users"._id
348	AND type = 'newDialogueChecks'
349	), '1970-01-01')
350	)
351	`)
352	}
353
354	async getUsersTopUpvotedUsers(user: DbUser, limit = 20, recencyLimitDays = 10): Promise<UpvotedUser[]> {	×
355	const karma = user?.karma ?? 0	×
356	const smallVotePower = calculateVotePower(karma, "smallUpvote");	×
357	const bigVotePower = calculateVotePower(karma, "bigUpvote");	×
358
359	return this.getRawDb().any(`	×
360	-- UsersRepo.getUsersTopUpvotedUsers
361	WITH "CombinedVotes" AS (
362	-- Joining Users with Posts and Votes
363	SELECT
364	v.power AS vote_power,
365	u._id AS user_id,
366	u.username AS user_username,
367	u."displayName" AS user_displayName,
368	CASE
369	WHEN v."extendedVoteType"->>'agreement' = 'bigDownvote' THEN -$3
370	WHEN v."extendedVoteType"->>'agreement' = 'smallDownvote' THEN -$2
371	WHEN v."extendedVoteType"->>'agreement' = 'neutral' THEN 0
372	WHEN v."extendedVoteType"->>'agreement' = 'smallUpvote' THEN $2
373	WHEN v."extendedVoteType"->>'agreement' = 'bigUpvote' THEN $3
374	ELSE 0
375	END AS agreement_value
376	FROM "Users" u
377	INNER JOIN "Posts" p ON u._id = p."userId"
378	INNER JOIN "Votes" v ON p._id = v."documentId"
379	WHERE
380	v."userId" = $1
381	AND u._id != $1
382	AND v."votedAt" > NOW() - INTERVAL '1.5 years'
383	AND v."cancelled" IS NOT TRUE
384
385	UNION ALL
386
387	-- Joining Users with Comments and Votes
388	SELECT
389	v.power AS vote_power,
390	u._id AS user_id,
391	u.username AS user_username,
392	u."displayName" AS user_displayName,
393	CASE
394	WHEN v."extendedVoteType"->>'agreement' = 'bigDownvote' THEN -$3
395	WHEN v."extendedVoteType"->>'agreement' = 'smallDownvote' THEN -$2
396	WHEN v."extendedVoteType"->>'agreement' = 'neutral' THEN 0
397	WHEN v."extendedVoteType"->>'agreement' = 'smallUpvote' THEN $2
398	WHEN v."extendedVoteType"->>'agreement' = 'bigUpvote' THEN $3
399	ELSE 0
400	END AS agreement_value
401	FROM "Users" u
402	INNER JOIN "Comments" c ON u._id = c."userId"
403	INNER JOIN "Votes" v ON c._id = v."documentId"
404	WHERE
405	v."userId" = $1
406	AND u._id != $1
407	AND v."votedAt" > NOW() - INTERVAL '1.5 years'
408	AND v."cancelled" IS NOT TRUE
409	),
410
411	"UserChecks" AS (
412	SELECT
413	u._id,
414	COALESCE(
415	EXISTS (
416	SELECT 1
417	FROM "DialogueChecks" as dc
418	WHERE
419	dc."userId" = u._id
420	AND "checkedAt" > NOW() - INTERVAL '$5 days'
421	),
422	FALSE
423	) AS recently_active_matchmaking
424	FROM "Users" as u
425	)
426
427	SELECT
428	user_id AS _id,
429	user_username AS username,
430	user_displayName AS "displayName",
431	SUM(vote_power) AS total_power,
432	ARRAY_AGG(vote_power) AS power_values,
433	COUNT(vote_power) AS vote_counts,
434	SUM(agreement_value) AS total_agreement,
435	ARRAY(
436	SELECT val
437	FROM UNNEST(ARRAY_AGG(agreement_value)) AS val
438	WHERE val != 0
439	) AS agreement_values,
440	uc.recently_active_matchmaking
441	FROM "CombinedVotes" as cv
442	LEFT JOIN "UserChecks" AS uc ON cv.user_id = uc._id
443	GROUP BY
444	user_id,
445	user_username,
446	user_displayName,
447	uc.recently_active_matchmaking
448	HAVING SUM(vote_power) > 1
449	ORDER BY total_power DESC
450	LIMIT $4;
451	`, [user._id, smallVotePower, bigVotePower, limit, recencyLimitDays])
452	}
453
454	async getDialogueMatchedUsers(userId: string): Promise<DbUser[]> {
455	return this.any(`	×
456	-- UsersRepo.getDialogueMatchedUsers
457	SELECT DISTINCT(u.*)
458	FROM "DialogueChecks" other_users_checks
459	JOIN "DialogueChecks" current_user_checks
460	-- Join such that there must exist reciprocal checks
461	ON (
462	other_users_checks."targetUserId" = current_user_checks."userId"
463	AND current_user_checks."targetUserId" = other_users_checks."userId"
464	AND other_users_checks.checked IS TRUE
465	AND current_user_checks.checked IS TRUE
466	)
467	JOIN "Users" u
468	-- Given those, join for users who've created checks on you
469	ON (
470	other_users_checks."userId" = u._id
471	AND other_users_checks."targetUserId" = $1
472	AND current_user_checks."userId" = $1
473	)
474	`, [userId]);
475	}
476
477	async getDialogueRecommendedUsers(userId: string, upvotedUsers: UpvotedUser[], limit = 100): Promise<DbUser[]> {	×
478	const upvotedUserIds = upvotedUsers.map(user => user._id);	×
479
480	return this.any(`	×
481	-- UsersRepo.getDialogueRecommendedUsers
482	(
483	SELECT u.*
484	FROM unnest($2::text[]) AS uv(_id)
485	INNER JOIN "Users" AS u ON uv._id = u._id
486	WHERE
487	-- Exclude users that the current user has already checked
488
489	(
490	SELECT COUNT(*)
491	FROM "DialogueChecks"
492	WHERE "userId" = $1 AND "targetUserId" = uv._id AND ("checked" IS TRUE OR "hideInRecommendations" IS TRUE)
493	) = 0
494	AND
495	(
496	-- Don't recommend users who've never commented on your posts
497
498	(
499	SELECT COUNT(*)
500	FROM public."Comments" AS c
501	INNER JOIN "Posts" AS p ON c."postId" = p._id
502	WHERE c."userId" = uv._id AND p."userId" = $1
503	) >= 1
504	OR
505	-- Don't recommend users who've never replied to your comments
506
507	(
508	SELECT COUNT(*)
509	FROM public."Comments"
510	WHERE
511	"userId" = uv._id
512	AND "parentCommentId" IN (
513	SELECT _id
514	FROM "Comments"
515	WHERE "userId" = $1
516	)
517	) >= 1
518	)
519	LIMIT $3
520	)
521	-- If the above query doesn't return enough users, then fill in the rest with users who you've upvoted
522	UNION
523	(
524	SELECT u.*
525	FROM unnest($2::text[]) AS uv(_id)
526	INNER JOIN "Users" AS u ON uv._id = u._id
527	WHERE
528	(
529	SELECT COUNT(*)
530	FROM "DialogueChecks"
531	WHERE "userId" = $1 AND "targetUserId" = uv._id AND ("checked" IS TRUE OR "hideInRecommendations" IS TRUE)
532	) = 0
533	LIMIT $3
534	)
535	`, [userId, upvotedUserIds, limit]);
536	}
537
538	async getActiveDialogueMatchSeekers(limit: number): Promise<DbUser[]> {
539	return this.manyOrNone(`	×
540	-- UsersRepo.getActiveDialogueMatchSeekers
541	SELECT
542	u.*,
543	MAX(dc."checkedAt") AS "mostRecentCheckedAt"
544	FROM public."Users" AS u
545	LEFT JOIN public."DialogueChecks" AS dc ON u._id = dc."userId"
546	WHERE dc."userId" IS NOT NULL
547	GROUP BY u._id
548	ORDER BY "mostRecentCheckedAt" DESC
549	LIMIT $1;
550	`, [limit])
551	}
552
553	async getActiveDialogues(userIds: string[]): Promise<ActiveDialogueServer[]> {
554	const result = await this.getRawDb().any(`	×
555	SELECT
556	p._id,
557	p.title,
558	p."userId",
559	p."coauthorStatuses",
560	ARRAY_AGG(DISTINCT s."userId") AS "activeUserIds",
561	MAX(r."editedAt") AS "mostRecentEditedAt"
562	FROM "Posts" AS p
563	INNER JOIN "Revisions" AS r ON p._id = r."documentId"
564	INNER JOIN "CkEditorUserSessions" AS s ON p._id = s."documentId",
565	unnest(p."coauthorStatuses") AS coauthors
566	WHERE
567	(
568	coauthors ->> 'userId' = any($1)
569	OR p."userId" = any($1)
570	)
571	AND s."endedAt" IS NULL
572	AND (
573	s."createdAt" > CURRENT_TIMESTAMP - INTERVAL '30 minutes'
574	OR r."editedAt" > CURRENT_TIMESTAMP - INTERVAL '30 minutes'
575	)
576	GROUP BY p._id
577	`, [userIds]);
578
579	return result;	×
580	}
581
582	async isDisplayNameTaken(displayName: string): Promise<boolean> {
583	const result = await this.getRawDb().one(`	×
584	-- UsersRepo.isDisplayNameTaken
585	SELECT COUNT(*) > 0 AS "isDisplayNameTaken"
586	FROM "Users"
587	WHERE "displayName" = $1
588	`, [displayName]);
589	return result.isDisplayNameTaken;	×
590	}
591
592	/**
593	* Returns a list of users who haven't read a post in over 4 months
594	* and who we want to email a feedback survey to.
595	*
596	* This excludes admins, deleted/deactivated users,
597	* flagged or purged or removed from queue users,
598	* users who were banned any time over the past 4 month period,
599	* and users who have already been sent this email.
600	*/
601	async getInactiveUsersToEmail(limit: number): Promise<DbUser[]> {
602	return this.manyOrNone(`	×
603	-- UsersRepo.getInactiveUsersToEmail
604	SELECT
605	u.*
606	FROM public."Users" AS u
607	LEFT JOIN (
608	SELECT "userId", MAX("lastUpdated") AS max_last_updated
609	FROM "ReadStatuses"
610	WHERE "isRead" IS TRUE
611	GROUP BY "userId"
612	) AS rs ON u._id = rs."userId"
613	WHERE
614	u."inactiveSurveyEmailSentAt" IS NULL
615	AND u."unsubscribeFromAll" IS NOT TRUE
616	AND u."isAdmin" IS NOT TRUE
617	AND u.deleted IS NOT TRUE
618	AND u."deleteContent" IS NOT TRUE
619	AND u."sunshineFlagged" IS NOT TRUE
620	AND (
621	u.banned IS NULL
622	OR u.banned < CURRENT_TIMESTAMP - INTERVAL '4 months'
623	)
624	AND (
625	u."reviewedByUserId" IS NOT NULL
626	OR u."sunshineNotes" IS NULL
627	OR u."sunshineNotes" = ''
628	)
629	AND (
630	(
631	rs.max_last_updated IS NULL
632	AND u."createdAt" < CURRENT_TIMESTAMP - INTERVAL '4 months'
633	)
634	OR (
635	rs.max_last_updated IS NOT NULL
636	AND rs.max_last_updated < CURRENT_TIMESTAMP - INTERVAL '4 months'
637	)
638	)
639	ORDER BY u."createdAt" desc
640	LIMIT $1;
641	`, [limit])
642	}
643
644	async getCurationSubscribedUserIds(): Promise<string[]> {
645	const verifiedEmailFilter = !isEAForum ? 'AND fm_has_verified_email(emails)' : '';	×
646
647	const userIdRecords = await this.getRawDb().any<Record<'_id', string>>(`	×
648	SELECT _id
649	FROM "Users"
650	WHERE "emailSubscribedToCurated" IS TRUE
651	AND "deleted" IS NOT TRUE
652	AND "email" IS NOT NULL
653	AND "unsubscribeFromAll" IS NOT TRUE
654	${verifiedEmailFilter}
655	`);
656
657	return userIdRecords.map(({ _id }) => _id);	×
658	}
659	}	19✔
660
661	recordPerfMetrics(UsersRepo, { excludeMethods: ['getUserByLoginToken'] });
662
663	export default UsersRepo;	19✔

ForumMagnum / ForumMagnum / 8723713852

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous