9981972752

Committed 17 Jul 2024 09:50PM UTC coverage: 31.866% (-0.05%) from 31.911%

Build # 9981972752

Build Type

Pull #9517

github

Committed by

Will-Howard

Commit Message

fix cases in userCallbacks

Pull Request Pull Request #9517: [Draft] Cleanup email verification logic so EAF never sends verification emails

Run Details

4907 of 40391 branches covered (12.15%)

Branch coverage included in aggregate %.

3 of 9 new or added lines in 5 files covered. (33.33%)

57 existing lines in 2 files now uncovered.

28712 of 65110 relevant lines covered (44.1%)

179.99 hits per line

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

37.87

/packages/lesswrong/server/callbacks/userCallbacks.tsx

import React from 'react';
import md5 from "md5";
import Users from "../../lib/collections/users/collection";
import { userGetGroups } from '../../lib/vulcan-users/permissions';
import { createMutator, updateMutator } from '../vulcan-lib/mutators';
import { Posts } from '../../lib/collections/posts'
import { Comments } from '../../lib/collections/comments'
import { bellNotifyEmailVerificationRequired } from '../notificationCallbacks';
import { isAnyTest } from '../../lib/executionEnvironment';
import { getCollectionHooks, UpdateCallbackProperties } from '../mutationCallbacks';
import { voteCallbacks, VoteDocTuple } from '../../lib/voting/vote';
import { encodeIntlError } from '../../lib/vulcan-lib/utils';
import { sendVerificationEmail } from "../vulcan-lib/apollo-server/authentication";
import { isEAForum, isLW, isLWorAF, verifyEmailsSetting } from "../../lib/instanceSettings";
import { mailchimpEAForumListIdSetting, mailchimpForumDigestListIdSetting, recombeeEnabledSetting } from "../../lib/publicSettings";
import { mailchimpAPIKeySetting } from "../../server/serverSettings";
import {userGetLocation, getUserEmail, userShortformPostTitle} from "../../lib/collections/users/helpers";
import { captureException } from "@sentry/core";
import { getAdminTeamAccount } from './commentCallbacks';
import { wrapAndSendEmail } from '../emails/renderEmail';
import { DatabaseServerSetting } from "../databaseSettings";
import { EventDebouncer } from '../debouncer';
import { Components } from '../../lib/vulcan-lib/components';
import { Conversations } from '../../lib/collections/conversations/collection';
import { Messages } from '../../lib/collections/messages/collection';
import { getAuth0Profile, updateAuth0Email } from '../authentication/auth0';
import { triggerReviewIfNeeded } from './sunshineCallbackUtils';
import isEqual from 'lodash/isEqual';
import {userFindOneByEmail} from "../commonQueries";
import { hasDigests } from '../../lib/betas';
import { recombeeApi } from '../recombee/client';
import { editableUserProfileFields, simpleUserProfileFields } from '../userProfileUpdates';

const MODERATE_OWN_PERSONAL_THRESHOLD = 50
const TRUSTLEVEL1_THRESHOLD = 2000

voteCallbacks.castVoteAsync.add(async function updateTrustedStatus ({newDocument, vote}: VoteDocTuple) {
  const user = await Users.findOne(newDocument.userId)
  if (user && (user?.karma) >= TRUSTLEVEL1_THRESHOLD && (!userGetGroups(user).includes('trustLevel1'))) {
    await Users.rawUpdateOne(user._id, {$push: {groups: 'trustLevel1'}});
    const updatedUser = await Users.findOne(newDocument.userId)
    //eslint-disable-next-line no-console
    console.info("User gained trusted status", updatedUser?.username, updatedUser?._id, updatedUser?.karma, updatedUser?.groups)
  }
});

voteCallbacks.castVoteAsync.add(async function updateModerateOwnPersonal({newDocument, vote}: VoteDocTuple) {
  const user = await Users.findOne(newDocument.userId)
  if (!user) throw Error("Couldn't find user")
  if ((user.karma) >= MODERATE_OWN_PERSONAL_THRESHOLD && (!userGetGroups(user).includes('canModeratePersonal'))) {
    await Users.rawUpdateOne(user._id, {$push: {groups: 'canModeratePersonal'}});
    const updatedUser = await Users.findOne(newDocument.userId)
    if (!updatedUser) throw Error("Couldn't find user to update")
    //eslint-disable-next-line no-console
    console.info("User gained trusted status", updatedUser.username, updatedUser._id, updatedUser.karma, updatedUser.groups)
  }
});

getCollectionHooks("Users").editBefore.add(async function UpdateAuth0Email(modifier: MongoModifier<DbUser>, user: DbUser) {
  const newEmail = modifier.$set?.email;
  const oldEmail = user.email;
  if (newEmail && newEmail !== oldEmail && isEAForum) {
    await updateAuth0Email(user, newEmail);
    /*
     * Be careful here: DbUser does NOT includes services, so overwriting
     * modifier.$set.services is both very easy and very bad (amongst other
     * things, it will invalidate the user's session)
     */
    modifier.$set["services.auth0"] = await getAuth0Profile(user);
  }
  return modifier;
});

getCollectionHooks("Users").editSync.add(function maybeSendVerificationEmail (modifier, user: DbUser)
{
  if(modifier.$set.whenConfirmationEmailSent
      && (!user.whenConfirmationEmailSent
          || user.whenConfirmationEmailSent.getTime() !== modifier.$set.whenConfirmationEmailSent.getTime()))
  {
    // Note: This is still gated by verifyEmailsSetting because `canUpdate` of whenConfirmationEmailSent is controlled by verifyEmailsSetting
    void sendVerificationEmail(user);
  }
});

getCollectionHooks("Users").editAsync.add(async function approveUnreviewedSubmissions (newUser: DbUser, oldUser: DbUser)
{
  if(newUser.reviewedByUserId && !oldUser.reviewedByUserId)
  {
    // For each post by this author which has the authorIsUnreviewed flag set,
    // clear the authorIsUnreviewed flag so it's visible, and update postedAt
    // to now so that it goes to the right place int he latest posts list.
    const unreviewedPosts = await Posts.find({userId: newUser._id, authorIsUnreviewed: true}).fetch();
    for (let post of unreviewedPosts) {
      await updateMutator<"Posts">({
        collection: Posts,
        documentId: post._id,
        set: {
          authorIsUnreviewed: false,
          postedAt: new Date(),
        },
        validate: false
      });
    }
    
    // For each comment by this author which has the authorIsUnreviewed flag set, clear the authorIsUnreviewed flag.
    // This only matters if the hideUnreviewedAuthorComments setting is active -
    // in that case, we want to trigger the relevant comment notifications once the author is reviewed.
    const unreviewedComments = await Comments.find({userId: newUser._id, authorIsUnreviewed: true}).fetch();
    for (let comment of unreviewedComments) {
      await updateMutator<"Comments">({
        collection: Comments,
        documentId: comment._id,
        set: {
          authorIsUnreviewed: false,
        },
        validate: false
      });
    }
  }
});

getCollectionHooks("Users").updateAsync.add(function updateUserMayTriggerReview({document, data}: UpdateCallbackProperties<"Users">) {
  const reviewTriggerFields: (keyof DbUser)[] = ['voteCount', 'mapLocation', 'postCount', 'commentCount', 'biography', 'profileImageId'];
  if (reviewTriggerFields.some(field => field in data)) {
    void triggerReviewIfNeeded(document._id)
  }
})

// When the very first user account is being created, add them to Sunshine
// Regiment. Patterned after a similar callback in
// vulcan-users/lib/server/callbacks.js which makes the first user an admin.
getCollectionHooks("Users").newSync.add(async function makeFirstUserAdminAndApproved (user: DbUser) {
  if (isAnyTest) return user;
  const realUsersCount = await Users.find({}).count();
  if (realUsersCount === 0) {
    user.reviewedByUserId = "firstAccount"; //HACK
    
    // Add the first user to the Sunshine Regiment
    if (!user.groups) user.groups = [];
    user.groups.push("sunshineRegiment");
  }
  return user;
});

getCollectionHooks("Users").editSync.add(function clearKarmaChangeBatchOnSettingsChange (modifier, user: DbUser)
{
  if (modifier.$set && modifier.$set.karmaChangeNotifierSettings) {
    if (!user.karmaChangeNotifierSettings.updateFrequency
      || modifier.$set.karmaChangeNotifierSettings.updateFrequency !== user.karmaChangeNotifierSettings.updateFrequency) {
      modifier.$set.karmaChangeLastOpened = null;
      modifier.$set.karmaChangeBatchStart = null;
    }
  }
});

getCollectionHooks("Users").newAsync.add(async function subscribeOnSignup (user: DbUser) {
  await sendVerificationEmailConditional(user);
});

getCollectionHooks("Users").editAsync.add(async function handleSetShortformPost (newUser: DbUser, oldUser: DbUser) {
  if (newUser.shortformFeedId !== oldUser.shortformFeedId)
  {
    const post = await Posts.findOne({_id: newUser.shortformFeedId});
    if (!post)
      throw new Error("Invalid post ID for shortform");
    if (post.userId !== newUser._id)
      throw new Error("Post can only be an author's short-form post if they are the post's author");
    if (post.draft)
      throw new Error("Draft post cannot be a user's short-form post");
    // @ts-ignore -- this should be something with post.status; post.deleted doesn't exist
    if (post.deleted)
      throw new Error("Deleted post cannot be a user's short-form post");
    
    // In theory, we should check here whether the user already had a short-form
    // post which is getting un-set, and clear the short-form flag from it. But
    // in the long run we won't need to do this, because creation of short-form
    // posts will be automatic-only, and as admins we can just not click the
    // set-as-shortform button on posts for users that already have a shortform.
    // So, don't bother checking for an old post in the shortformFeedId field.
    
    // Mark the post as shortform
    await updateMutator({
      collection: Posts,
      documentId: post._id,
      set: { shortform: true },
      unset: {},
      validate: false,
    });
  }
});

getCollectionHooks("Users").newSync.add(async function usersMakeAdmin (user: DbUser) {
  if (isAnyTest) return user;
  // if this is not a dummy account, and is the first user ever, make them an admin
  // TODO: should use await Connectors.count() instead, but cannot await inside Accounts.onCreateUser. Fix later. 
  if (typeof user.isAdmin === 'undefined') {
    const realUsersCount = await Users.find({}).count();
    user.isAdmin = (realUsersCount === 0);
  }
  return user;
});

const sendVerificationEmailConditional = async  (user: DbUser) => {
  if (!isAnyTest && verifyEmailsSetting.get()) {
    void sendVerificationEmail(user);
    await bellNotifyEmailVerificationRequired(user);
  }
}

getCollectionHooks("Users").editSync.add(async function usersEditCheckEmail (modifier, user: DbUser) {
  // if email is being modified, update user.emails too
  if (modifier.$set && modifier.$set.email) {

    const newEmail = modifier.$set.email;

    // check for existing emails and throw error if necessary
    const userWithSameEmail = await userFindOneByEmail(newEmail);
    if (userWithSameEmail && userWithSameEmail._id !== user._id) {
      throw new Error(encodeIntlError({id:'users.email_already_taken', value: newEmail}));
    }

    // if user.emails exists, change it too
    if (!!user.emails && user.emails.length) {
      if (user.emails[0].address !== newEmail) {
        user.emails[0].address = newEmail;
        user.emails[0].verified = false;
        modifier.$set.emails = user.emails;
        await sendVerificationEmailConditional(user)
      }
    } else {
      modifier.$set.emails = [{address: newEmail, verified: false}];
      await sendVerificationEmailConditional(user)
    }
  }
  return modifier;
});

/**
 * Handle subscribing/unsubscribing in mailchimp when `subscribedToDigest` is changed, including cases where this
 * happens implicitly due to changing another field
 */
getCollectionHooks("Users").updateBefore.add(async function updateDigestSubscription(data: DbUser, {oldDocument}) {
  // Handle cases which force you to unsubscribe from the digest:
  // - When a user explicitly unsubscribes from all emails. If they want they can then explicitly re-subscribe
  // to the digest while keeping "unsubscribeFromAll" checked
  // - When a user deactivates their account
  const unsubscribedFromAll = data.unsubscribeFromAll && !oldDocument.unsubscribeFromAll
  const deactivatedAccount = data.deleted && !oldDocument.deleted
  if (hasDigests && (unsubscribedFromAll || deactivatedAccount)) {
    data.subscribedToDigest = false
  }

  const handleErrorCase = (errorMessage: string) => {
    // If the user is deactivating their account, allow the update to continue. Otherwise,
    // the user is explicitly trying to update their subscription, so throw and block the update
    const err = new Error(errorMessage)
    captureException(err)
    if (!deactivatedAccount) {
      throw err
    }
    data.subscribedToDigest = false
    return data;
  }

  if (
    isAnyTest ||
    !hasDigests ||
    data.subscribedToDigest === undefined || // When a mutation doesn't reference subscribedToDigest
    data.subscribedToDigest === oldDocument.subscribedToDigest
  ) {
    return data;
  }

  const mailchimpAPIKey = mailchimpAPIKeySetting.get();
  const mailchimpForumDigestListId = mailchimpForumDigestListIdSetting.get();
  if (!mailchimpAPIKey || !mailchimpForumDigestListId) {
    return handleErrorCase("Error updating digest subscription: Mailchimp not configured")
  }

  const email = getUserEmail(data)
  if (!email) {
    return handleErrorCase(`Error updating digest subscription: no email for user ${data.displayName}`)
  }

  const { lat: latitude, lng: longitude, known } = userGetLocation(data);
  const status = data.subscribedToDigest ? 'subscribed' : 'unsubscribed';
  const emailHash = md5(email!.toLowerCase());

  const res = await fetch(`https://us8.api.mailchimp.com/3.0/lists/${mailchimpForumDigestListId}/members/${emailHash}`, {
    method: 'PUT',
    body: JSON.stringify({
      email_address: email,
      email_type: 'html', 
      ...(known && {location: {
        latitude,
        longitude,
      }}),
      merge_fields: {
        FNAME: data.displayName,
      },
      status,
    }),
    headers: {
      'Content-Type': 'application/json',
      Authorization: `API_KEY ${mailchimpAPIKey}`,
    },
  });

  if (res?.status === 200) {
    return data;
  }

  const json = await res.json()
  return handleErrorCase(`Error updating digest subscription: ${json.detail || res?.statusText || 'Unknown error'}`)
});

/**
 * This callback adds all new users to an audience in Mailchimp which will be used for a forthcoming
 * (as of 2021-08-11) drip campaign.
 */
getCollectionHooks("Users").newAsync.add(async function subscribeToEAForumAudience(user: DbUser) {
  if (isAnyTest || !isEAForum) {
    return;
  }
  const mailchimpAPIKey = mailchimpAPIKeySetting.get();
  const mailchimpEAForumListId = mailchimpEAForumListIdSetting.get();
  if (!mailchimpAPIKey || !mailchimpEAForumListId) {
    return;
  }
  if (!user.email) {
    captureException(new Error(`Subscription to EA Forum audience failed: no email for user ${user.displayName}`))
    return;
  }
  const { lat: latitude, lng: longitude, known } = userGetLocation(user);
  void fetch(`https://us8.api.mailchimp.com/3.0/lists/${mailchimpEAForumListId}/members`, {
    method: 'POST',
    body: JSON.stringify({
      email_address: user.email,
      email_type: 'html', 
      ...(known && {location: {
        latitude,
        longitude,
      }}),
      status: "subscribed",
    }),
    headers: {
      'Content-Type': 'application/json',
      Authorization: `API_KEY ${mailchimpAPIKey}`,
    },
  }).catch(e => {
    captureException(e);
    // eslint-disable-next-line no-console
    console.log(e);
  });
});

const welcomeMessageDelayer = new EventDebouncer({
  name: "welcomeMessageDelay",
  
  // Delay is by default 60 minutes between when you create an account, and
  // when we send the welcome email. The theory is that users creating new
  // accounts are often doing so because they're about to write a comment or
  // something, and derailing them with a bunch of stuff to read at that
  // particular moment could be bad.
  // LW wants people to see site intro before posting
  defaultTiming: isLW ? {type: "none"} : {type: "delayed", delayMinutes: 60},
  
  callback: (userId: string) => {
    void sendWelcomeMessageTo(userId);
  },
});

getCollectionHooks("Users").newAsync.add(async function sendWelcomingPM(user: DbUser) {
  await welcomeMessageDelayer.recordEvent({
    key: user._id,
  });
});

const welcomeEmailPostId = new DatabaseServerSetting<string|null>("welcomeEmailPostId", null);
const forumTeamUserId = new DatabaseServerSetting<string|null>("forumTeamUserId", null);

async function sendWelcomeMessageTo(userId: string) {
  const postId = welcomeEmailPostId.get();
  if (!postId || !postId.length) {
    // eslint-disable-next-line no-console
    console.log("Not sending welcome email, welcomeEmailPostId setting is not configured");
    return;
  }
  const welcomePost = await Posts.findOne({_id: postId});
  if (!welcomePost) {
    // eslint-disable-next-line no-console
    console.error(`Not sending welcome email, welcomeEmailPostId of ${postId} does not match any post`);
    return;
  }
  
  const user = await Users.findOne(userId);
  if (!user) throw new Error(`Could not find ${userId}`);
  
  // try to use forumTeamUserId as the sender,
  // and default to the admin account if not found
  const adminUserId = forumTeamUserId.get()
  let adminsAccount = adminUserId ? await Users.findOne({_id: adminUserId}) : null
  if (!adminsAccount) {
    adminsAccount = await getAdminTeamAccount()
    if (!adminsAccount) {
      throw new Error("Could not find admin account")
    }
  }
  
  const subjectLine = welcomePost.title;
  const welcomeMessageBody = welcomePost.contents?.html ?? "";
  
  const conversationData = {
    participantIds: [user._id, adminsAccount._id],
    title: subjectLine,
  }
  const conversation = await createMutator({
    collection: Conversations,
    document: conversationData,
    currentUser: adminsAccount,
    validate: false
  });
  
  const messageDocument = {
    userId: adminsAccount._id,
    contents: {
      originalContents: {
        type: "html",
        data: welcomeMessageBody,
      }
    },
    conversationId: conversation.data._id,
    noEmail: true,
  }
  await createMutator({
    collection: Messages,
    document: messageDocument,
    currentUser: adminsAccount,
    validate: false
  })
  
  // the EA Forum has a separate "welcome email" series that is sent via mailchimp,
  // so we're not sending the email notification for this welcome PM
  if (!isEAForum) {
    await wrapAndSendEmail({
      user,
      subject: subjectLine,
      body: <Components.EmailContentItemBody dangerouslySetInnerHTML={{ __html: welcomeMessageBody }}/>
    })
  }
}

getCollectionHooks("Users").updateBefore.add(async function UpdateDisplayName(data: DbUser, {oldDocument}) {
  if (data.displayName !== undefined && data.displayName !== oldDocument.displayName) {
    if (!data.displayName) {
      throw new Error("You must enter a display name");
    }
    if (await Users.findOne({displayName: data.displayName})) {
      throw new Error("This display name is already taken");
    }
    if (data.shortformFeedId && !isLWorAF) {
      void updateMutator({
        collection: Posts,
        documentId: data.shortformFeedId,
        set: {title: userShortformPostTitle(data)},
        validate: false,
      });
    }
  }
  return data;
});

getCollectionHooks("Users").createAsync.add(({ document }) => {
  if (!recombeeEnabledSetting.get()) return;

  void recombeeApi.createUser(document)
    // eslint-disable-next-line no-console
    .catch(e => console.log('Error when sending created user to recombee', { e }));
});

getCollectionHooks("Users").editSync.add(function syncProfileUpdatedAt(modifier, user: DbUser) {
  for (const field of simpleUserProfileFields) {
    if (
      (field in modifier.$set && !isEqual(modifier.$set[field], user[field])) ||
      (field in modifier.$unset && (user[field] !== null && user[field] !== undefined))
    ) {
      modifier.$set.profileUpdatedAt = new Date();
      return modifier;
    }
  }
  for (const field of editableUserProfileFields) {
    if (field in modifier.$set && modifier.$set[field]?.html !== user[field]?.html) {
      modifier.$set.profileUpdatedAt = new Date();
      return modifier;
    }
  }
  return modifier;
});

1	import React from 'react';	18✔
2	import md5 from "md5";	18✔
3	import Users from "../../lib/collections/users/collection";	18✔
4	import { userGetGroups } from '../../lib/vulcan-users/permissions';	18✔
5	import { createMutator, updateMutator } from '../vulcan-lib/mutators';	18✔
6	import { Posts } from '../../lib/collections/posts'	18✔
7	import { Comments } from '../../lib/collections/comments'	18✔
8	import { bellNotifyEmailVerificationRequired } from '../notificationCallbacks';	18✔
9	import { isAnyTest } from '../../lib/executionEnvironment';	18✔
10	import { getCollectionHooks, UpdateCallbackProperties } from '../mutationCallbacks';	18✔
11	import { voteCallbacks, VoteDocTuple } from '../../lib/voting/vote';	18✔
12	import { encodeIntlError } from '../../lib/vulcan-lib/utils';	18✔
13	import { sendVerificationEmail } from "../vulcan-lib/apollo-server/authentication";	18✔
14	import { isEAForum, isLW, isLWorAF, verifyEmailsSetting } from "../../lib/instanceSettings";	18✔
15	import { mailchimpEAForumListIdSetting, mailchimpForumDigestListIdSetting, recombeeEnabledSetting } from "../../lib/publicSettings";	18✔
16	import { mailchimpAPIKeySetting } from "../../server/serverSettings";	18✔
17	import {userGetLocation, getUserEmail, userShortformPostTitle} from "../../lib/collections/users/helpers";	18✔
18	import { captureException } from "@sentry/core";	18✔
19	import { getAdminTeamAccount } from './commentCallbacks';	18✔
20	import { wrapAndSendEmail } from '../emails/renderEmail';	18✔
21	import { DatabaseServerSetting } from "../databaseSettings";	18✔
22	import { EventDebouncer } from '../debouncer';	18✔
23	import { Components } from '../../lib/vulcan-lib/components';	18✔
24	import { Conversations } from '../../lib/collections/conversations/collection';	18✔
25	import { Messages } from '../../lib/collections/messages/collection';	18✔
26	import { getAuth0Profile, updateAuth0Email } from '../authentication/auth0';	18✔
27	import { triggerReviewIfNeeded } from './sunshineCallbackUtils';	18✔
28	import isEqual from 'lodash/isEqual';	18✔
29	import {userFindOneByEmail} from "../commonQueries";	18✔
30	import { hasDigests } from '../../lib/betas';	18✔
31	import { recombeeApi } from '../recombee/client';	18✔
32	import { editableUserProfileFields, simpleUserProfileFields } from '../userProfileUpdates';	18✔
33
34	const MODERATE_OWN_PERSONAL_THRESHOLD = 50	18✔
35	const TRUSTLEVEL1_THRESHOLD = 2000	18✔
36
37	voteCallbacks.castVoteAsync.add(async function updateTrustedStatus ({newDocument, vote}: VoteDocTuple) {	18✔
38	const user = await Users.findOne(newDocument.userId)	142✔
39	if (user && (user?.karma) >= TRUSTLEVEL1_THRESHOLD && (!userGetGroups(user).includes('trustLevel1'))) {	142!
40	await Users.rawUpdateOne(user._id, {$push: {groups: 'trustLevel1'}});	×
41	const updatedUser = await Users.findOne(newDocument.userId)	×
42	//eslint-disable-next-line no-console
43	console.info("User gained trusted status", updatedUser?.username, updatedUser?._id, updatedUser?.karma, updatedUser?.groups)	×
44	}
45	});
46
47	voteCallbacks.castVoteAsync.add(async function updateModerateOwnPersonal({newDocument, vote}: VoteDocTuple) {	18✔
48	const user = await Users.findOne(newDocument.userId)	142✔
49	if (!user) throw Error("Couldn't find user")	142!
50	if ((user.karma) >= MODERATE_OWN_PERSONAL_THRESHOLD && (!userGetGroups(user).includes('canModeratePersonal'))) {	142!
51	await Users.rawUpdateOne(user._id, {$push: {groups: 'canModeratePersonal'}});	×
52	const updatedUser = await Users.findOne(newDocument.userId)	×
53	if (!updatedUser) throw Error("Couldn't find user to update")	×
54	//eslint-disable-next-line no-console
55	console.info("User gained trusted status", updatedUser.username, updatedUser._id, updatedUser.karma, updatedUser.groups)	×
56	}
57	});	18✔
58
59	getCollectionHooks("Users").editBefore.add(async function UpdateAuth0Email(modifier: MongoModifier<DbUser>, user: DbUser) {
60	const newEmail = modifier.$set?.email;	12!
61	const oldEmail = user.email;	12✔
62	if (newEmail && newEmail !== oldEmail && isEAForum) {	12!
63	await updateAuth0Email(user, newEmail);	×
64	/*
65	* Be careful here: DbUser does NOT includes services, so overwriting
66	* modifier.$set.services is both very easy and very bad (amongst other
67	* things, it will invalidate the user's session)
68	*/
69	modifier.$set["services.auth0"] = await getAuth0Profile(user);	×
70	}
71	return modifier;	12✔
72	});	18✔
73
74	getCollectionHooks("Users").editSync.add(function maybeSendVerificationEmail (modifier, user: DbUser)
75	{
76	if(modifier.$set.whenConfirmationEmailSent	12!
77	&& (!user.whenConfirmationEmailSent
78	\|\| user.whenConfirmationEmailSent.getTime() !== modifier.$set.whenConfirmationEmailSent.getTime()))
79	{
80	// Note: This is still gated by verifyEmailsSetting because `canUpdate` of whenConfirmationEmailSent is controlled by verifyEmailsSetting
UNCOV 81	void sendVerificationEmail(user);	×
82	}
83	});	18✔
84
85	getCollectionHooks("Users").editAsync.add(async function approveUnreviewedSubmissions (newUser: DbUser, oldUser: DbUser)
86	{
87	if(newUser.reviewedByUserId && !oldUser.reviewedByUserId)	12!
88	{
89	// For each post by this author which has the authorIsUnreviewed flag set,
90	// clear the authorIsUnreviewed flag so it's visible, and update postedAt
91	// to now so that it goes to the right place int he latest posts list.
92	const unreviewedPosts = await Posts.find({userId: newUser._id, authorIsUnreviewed: true}).fetch();	×
93	for (let post of unreviewedPosts) {	×
94	await updateMutator<"Posts">({	×
95	collection: Posts,
96	documentId: post._id,
97	set: {
98	authorIsUnreviewed: false,
99	postedAt: new Date(),
100	},
101	validate: false
102	});
103	}
104
105	// For each comment by this author which has the authorIsUnreviewed flag set, clear the authorIsUnreviewed flag.
106	// This only matters if the hideUnreviewedAuthorComments setting is active -
107	// in that case, we want to trigger the relevant comment notifications once the author is reviewed.
108	const unreviewedComments = await Comments.find({userId: newUser._id, authorIsUnreviewed: true}).fetch();	×
109	for (let comment of unreviewedComments) {	×
110	await updateMutator<"Comments">({	×
111	collection: Comments,
112	documentId: comment._id,
113	set: {
114	authorIsUnreviewed: false,
115	},
116	validate: false
117	});
118	}
119	}
120	});	18✔
121
122	getCollectionHooks("Users").updateAsync.add(function updateUserMayTriggerReview({document, data}: UpdateCallbackProperties<"Users">) {
123	const reviewTriggerFields: (keyof DbUser)[] = ['voteCount', 'mapLocation', 'postCount', 'commentCount', 'biography', 'profileImageId'];	12✔
124	if (reviewTriggerFields.some(field => field in data)) {	72!
125	void triggerReviewIfNeeded(document._id)	×
126	}
127	})	18✔
128
129	// When the very first user account is being created, add them to Sunshine
130	// Regiment. Patterned after a similar callback in
131	// vulcan-users/lib/server/callbacks.js which makes the first user an admin.
132	getCollectionHooks("Users").newSync.add(async function makeFirstUserAdminAndApproved (user: DbUser) {
133	if (isAnyTest) return user;	167!
134	const realUsersCount = await Users.find({}).count();	×
135	if (realUsersCount === 0) {	×
136	user.reviewedByUserId = "firstAccount"; //HACK	×
137
138	// Add the first user to the Sunshine Regiment
139	if (!user.groups) user.groups = [];	×
140	user.groups.push("sunshineRegiment");	×
141	}
142	return user;	×
143	});	18✔
144
145	getCollectionHooks("Users").editSync.add(function clearKarmaChangeBatchOnSettingsChange (modifier, user: DbUser)
146	{
147	if (modifier.$set && modifier.$set.karmaChangeNotifierSettings) {	12!
148	if (!user.karmaChangeNotifierSettings.updateFrequency	×
149	\|\| modifier.$set.karmaChangeNotifierSettings.updateFrequency !== user.karmaChangeNotifierSettings.updateFrequency) {
150	modifier.$set.karmaChangeLastOpened = null;	×
151	modifier.$set.karmaChangeBatchStart = null;	×
152	}
153	}
154	});	18✔
155
156	getCollectionHooks("Users").newAsync.add(async function subscribeOnSignup (user: DbUser) {
157	await sendVerificationEmailConditional(user);	167✔
158	});	18✔
159
160	getCollectionHooks("Users").editAsync.add(async function handleSetShortformPost (newUser: DbUser, oldUser: DbUser) {
161	if (newUser.shortformFeedId !== oldUser.shortformFeedId)	12!
162	{
163	const post = await Posts.findOne({_id: newUser.shortformFeedId});	×
164	if (!post)	×
165	throw new Error("Invalid post ID for shortform");	×
166	if (post.userId !== newUser._id)	×
167	throw new Error("Post can only be an author's short-form post if they are the post's author");	×
168	if (post.draft)	×
169	throw new Error("Draft post cannot be a user's short-form post");	×
170	// @ts-ignore -- this should be something with post.status; post.deleted doesn't exist
171	if (post.deleted)	×
172	throw new Error("Deleted post cannot be a user's short-form post");	×
173
174	// In theory, we should check here whether the user already had a short-form
175	// post which is getting un-set, and clear the short-form flag from it. But
176	// in the long run we won't need to do this, because creation of short-form
177	// posts will be automatic-only, and as admins we can just not click the
178	// set-as-shortform button on posts for users that already have a shortform.
179	// So, don't bother checking for an old post in the shortformFeedId field.
180
181	// Mark the post as shortform
182	await updateMutator({	×
183	collection: Posts,
184	documentId: post._id,
185	set: { shortform: true },
186	unset: {},
187	validate: false,
188	});
189	}
190	});	18✔
191
192	getCollectionHooks("Users").newSync.add(async function usersMakeAdmin (user: DbUser) {
193	if (isAnyTest) return user;	167!
194	// if this is not a dummy account, and is the first user ever, make them an admin
195	// TODO: should use await Connectors.count() instead, but cannot await inside Accounts.onCreateUser. Fix later.
196	if (typeof user.isAdmin === 'undefined') {	×
197	const realUsersCount = await Users.find({}).count();	×
198	user.isAdmin = (realUsersCount === 0);	×
199	}
200	return user;	×
201	});
202
203	const sendVerificationEmailConditional = async (user: DbUser) => {	18✔
204	if (!isAnyTest && verifyEmailsSetting.get()) {	167!
205	void sendVerificationEmail(user);	×
206	await bellNotifyEmailVerificationRequired(user);	×
207	}
208	}	18✔
209
210	getCollectionHooks("Users").editSync.add(async function usersEditCheckEmail (modifier, user: DbUser) {
211	// if email is being modified, update user.emails too
212	if (modifier.$set && modifier.$set.email) {	12!
213
214	const newEmail = modifier.$set.email;	×
215
216	// check for existing emails and throw error if necessary
217	const userWithSameEmail = await userFindOneByEmail(newEmail);	×
218	if (userWithSameEmail && userWithSameEmail._id !== user._id) {	×
219	throw new Error(encodeIntlError({id:'users.email_already_taken', value: newEmail}));	×
220	}
221
222	// if user.emails exists, change it too
223	if (!!user.emails && user.emails.length) {	×
224	if (user.emails[0].address !== newEmail) {	×
225	user.emails[0].address = newEmail;	×
226	user.emails[0].verified = false;	×
227	modifier.$set.emails = user.emails;	×
228	await sendVerificationEmailConditional(user)	×
229	}
230	} else {
231	modifier.$set.emails = [{address: newEmail, verified: false}];	×
232	await sendVerificationEmailConditional(user)	×
233	}
234	}
235	return modifier;	12✔
236	});	18✔
237
238	/**
239	* Handle subscribing/unsubscribing in mailchimp when `subscribedToDigest` is changed, including cases where this
240	* happens implicitly due to changing another field
241	*/
242	getCollectionHooks("Users").updateBefore.add(async function updateDigestSubscription(data: DbUser, {oldDocument}) {
243	// Handle cases which force you to unsubscribe from the digest:
244	// - When a user explicitly unsubscribes from all emails. If they want they can then explicitly re-subscribe
245	// to the digest while keeping "unsubscribeFromAll" checked
246	// - When a user deactivates their account
247	const unsubscribedFromAll = data.unsubscribeFromAll && !oldDocument.unsubscribeFromAll	12!
248	const deactivatedAccount = data.deleted && !oldDocument.deleted	12!
249	if (hasDigests && (unsubscribedFromAll \|\| deactivatedAccount)) {	12!
250	data.subscribedToDigest = false	×
251	}
252
253	const handleErrorCase = (errorMessage: string) => {	12✔
254	// If the user is deactivating their account, allow the update to continue. Otherwise,
255	// the user is explicitly trying to update their subscription, so throw and block the update
256	const err = new Error(errorMessage)	×
257	captureException(err)	×
258	if (!deactivatedAccount) {	×
259	throw err	×
260	}
261	data.subscribedToDigest = false	×
262	return data;	×
263	}
264
265	if (	12!
266	isAnyTest \|\|	12!
267	!hasDigests \|\|
268	data.subscribedToDigest === undefined \|\| // When a mutation doesn't reference subscribedToDigest
269	data.subscribedToDigest === oldDocument.subscribedToDigest
270	) {
271	return data;	12✔
272	}
273
274	const mailchimpAPIKey = mailchimpAPIKeySetting.get();	×
275	const mailchimpForumDigestListId = mailchimpForumDigestListIdSetting.get();	×
276	if (!mailchimpAPIKey \|\| !mailchimpForumDigestListId) {	×
277	return handleErrorCase("Error updating digest subscription: Mailchimp not configured")	×
278	}
279
280	const email = getUserEmail(data)	×
281	if (!email) {	×
282	return handleErrorCase(`Error updating digest subscription: no email for user ${data.displayName}`)	×
283	}
284
285	const { lat: latitude, lng: longitude, known } = userGetLocation(data);	×
286	const status = data.subscribedToDigest ? 'subscribed' : 'unsubscribed';	×
287	const emailHash = md5(email!.toLowerCase());	×
288
289	const res = await fetch(`https://us8.api.mailchimp.com/3.0/lists/${mailchimpForumDigestListId}/members/${emailHash}`, {	×
290	method: 'PUT',
291	body: JSON.stringify({
292	email_address: email,
293	email_type: 'html',
294	...(known && {location: {	×
295	latitude,
296	longitude,
297	}}),
298	merge_fields: {
299	FNAME: data.displayName,
300	},
301	status,
302	}),
303	headers: {
304	'Content-Type': 'application/json',
305	Authorization: `API_KEY ${mailchimpAPIKey}`,
306	},
307	});
308
309	if (res?.status === 200) {	×
310	return data;	×
311	}
312
313	const json = await res.json()	×
314	return handleErrorCase(`Error updating digest subscription: ${json.detail \|\| res?.statusText \|\| 'Unknown error'}`)	×
315	});	18✔
316
317	/**
318	* This callback adds all new users to an audience in Mailchimp which will be used for a forthcoming
319	* (as of 2021-08-11) drip campaign.
320	*/
321	getCollectionHooks("Users").newAsync.add(async function subscribeToEAForumAudience(user: DbUser) {
322	if (isAnyTest \|\| !isEAForum) {	167!
323	return;	167✔
324	}
325	const mailchimpAPIKey = mailchimpAPIKeySetting.get();	×
326	const mailchimpEAForumListId = mailchimpEAForumListIdSetting.get();	×
327	if (!mailchimpAPIKey \|\| !mailchimpEAForumListId) {	×
328	return;	×
329	}
330	if (!user.email) {	×
331	captureException(new Error(`Subscription to EA Forum audience failed: no email for user ${user.displayName}`))	×
332	return;	×
333	}
334	const { lat: latitude, lng: longitude, known } = userGetLocation(user);	×
335	void fetch(`https://us8.api.mailchimp.com/3.0/lists/${mailchimpEAForumListId}/members`, {	×
336	method: 'POST',
337	body: JSON.stringify({
338	email_address: user.email,
339	email_type: 'html',
340	...(known && {location: {	×
341	latitude,
342	longitude,
343	}}),
344	status: "subscribed",
345	}),
346	headers: {
347	'Content-Type': 'application/json',
348	Authorization: `API_KEY ${mailchimpAPIKey}`,
349	},
350	}).catch(e => {
351	captureException(e);	×
352	// eslint-disable-next-line no-console
353	console.log(e);	×
354	});
355	});
356
357	const welcomeMessageDelayer = new EventDebouncer({	18✔
358	name: "welcomeMessageDelay",
359
360	// Delay is by default 60 minutes between when you create an account, and
361	// when we send the welcome email. The theory is that users creating new
362	// accounts are often doing so because they're about to write a comment or
363	// something, and derailing them with a bunch of stuff to read at that
364	// particular moment could be bad.
365	// LW wants people to see site intro before posting
366	defaultTiming: isLW ? {type: "none"} : {type: "delayed", delayMinutes: 60},	18!
367
368	callback: (userId: string) => {
369	void sendWelcomeMessageTo(userId);	×
370	},
371	});	18✔
372
373	getCollectionHooks("Users").newAsync.add(async function sendWelcomingPM(user: DbUser) {
374	await welcomeMessageDelayer.recordEvent({	167✔
375	key: user._id,
376	});
377	});
378
379	const welcomeEmailPostId = new DatabaseServerSetting<string\|null>("welcomeEmailPostId", null);	18✔
380	const forumTeamUserId = new DatabaseServerSetting<string\|null>("forumTeamUserId", null);	18✔
381
382	async function sendWelcomeMessageTo(userId: string) {
383	const postId = welcomeEmailPostId.get();	×
384	if (!postId \|\| !postId.length) {	×
385	// eslint-disable-next-line no-console
386	console.log("Not sending welcome email, welcomeEmailPostId setting is not configured");	×
387	return;	×
388	}
389	const welcomePost = await Posts.findOne({_id: postId});	×
390	if (!welcomePost) {	×
391	// eslint-disable-next-line no-console
392	console.error(`Not sending welcome email, welcomeEmailPostId of ${postId} does not match any post`);	×
393	return;	×
394	}
395
396	const user = await Users.findOne(userId);	×
397	if (!user) throw new Error(`Could not find ${userId}`);	×
398
399	// try to use forumTeamUserId as the sender,
400	// and default to the admin account if not found
401	const adminUserId = forumTeamUserId.get()	×
402	let adminsAccount = adminUserId ? await Users.findOne({_id: adminUserId}) : null	×
403	if (!adminsAccount) {	×
404	adminsAccount = await getAdminTeamAccount()	×
405	if (!adminsAccount) {	×
406	throw new Error("Could not find admin account")	×
407	}
408	}
409
410	const subjectLine = welcomePost.title;	×
411	const welcomeMessageBody = welcomePost.contents?.html ?? "";	×
412
413	const conversationData = {	×
414	participantIds: [user._id, adminsAccount._id],
415	title: subjectLine,
416	}
417	const conversation = await createMutator({	×
418	collection: Conversations,
419	document: conversationData,
420	currentUser: adminsAccount,
421	validate: false
422	});
423
424	const messageDocument = {	×
425	userId: adminsAccount._id,
426	contents: {
427	originalContents: {
428	type: "html",
429	data: welcomeMessageBody,
430	}
431	},
432	conversationId: conversation.data._id,
433	noEmail: true,
434	}
435	await createMutator({	×
436	collection: Messages,
437	document: messageDocument,
438	currentUser: adminsAccount,
439	validate: false
440	})
441
442	// the EA Forum has a separate "welcome email" series that is sent via mailchimp,
443	// so we're not sending the email notification for this welcome PM
444	if (!isEAForum) {	×
445	await wrapAndSendEmail({	×
446	user,
447	subject: subjectLine,
448	body: <Components.EmailContentItemBody dangerouslySetInnerHTML={{ __html: welcomeMessageBody }}/>
449	})
450	}
451	}	18✔
452
453	getCollectionHooks("Users").updateBefore.add(async function UpdateDisplayName(data: DbUser, {oldDocument}) {
454	if (data.displayName !== undefined && data.displayName !== oldDocument.displayName) {	12✔
455	if (!data.displayName) {	1!
456	throw new Error("You must enter a display name");	×
457	}
458	if (await Users.findOne({displayName: data.displayName})) {	1!
459	throw new Error("This display name is already taken");	×
460	}
461	if (data.shortformFeedId && !isLWorAF) {	1!
462	void updateMutator({	×
463	collection: Posts,
464	documentId: data.shortformFeedId,
465	set: {title: userShortformPostTitle(data)},
466	validate: false,
467	});
468	}
469	}
470	return data;	12✔
471	});	18✔
472
473	getCollectionHooks("Users").createAsync.add(({ document }) => {
474	if (!recombeeEnabledSetting.get()) return;	167!
475
476	void recombeeApi.createUser(document)	×
477	// eslint-disable-next-line no-console
478	.catch(e => console.log('Error when sending created user to recombee', { e }));	×
479	});	18✔
480
481	getCollectionHooks("Users").editSync.add(function syncProfileUpdatedAt(modifier, user: DbUser) {
482	for (const field of simpleUserProfileFields) {	12✔
483	if (	189✔
484	(field in modifier.$set && !isEqual(modifier.$set[field], user[field])) \|\|	378!
485	(field in modifier.$unset && (user[field] !== null && user[field] !== undefined))
486	) {
487	modifier.$set.profileUpdatedAt = new Date();	1✔
488	return modifier;	1✔
489	}
490	}
491	for (const field of editableUserProfileFields) {	11✔
492	if (field in modifier.$set && modifier.$set[field]?.html !== user[field]?.html) {	33!
493	modifier.$set.profileUpdatedAt = new Date();	×
494	return modifier;	×
495	}
496	}
497	return modifier;	11✔
498	});

ForumMagnum / ForumMagnum / 9981972752

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