9022431366

Committed 09 May 2024 07:22PM UTC coverage: 31.923% (+0.02%) from 31.903%

Build # 9022431366

Build Type

Pull #9224

github

Committed by

jimrandomh

Commit Message

Fix Cypress test failure

Pull Request Pull Request #9224: Fix rerender-flash when you vote on a comment that has a YouTube embed in it

Run Details

4726 of 38669 branches covered (12.22%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

329 existing lines in 12 files now uncovered.

27576 of 62519 relevant lines covered (44.11%)

178.63 hits per line

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

7.45

/packages/lesswrong/server/scripts/mergeAccounts.ts

import Users from '../../lib/collections/users/collection';
import { Vulcan, updateMutator, getCollection, Utils } from '../vulcan-lib';
import { Revisions } from '../../lib/collections/revisions/collection';
import { editableCollectionsFields } from '../../lib/editor/make_editable'
import ReadStatuses from '../../lib/collections/readStatus/collection';
import { Votes } from '../../lib/collections/votes/index';
import { Conversations } from '../../lib/collections/conversations/collection'
import { asyncForeachSequential } from '../../lib/utils/asyncUtils';
import sumBy from 'lodash/sumBy';
import { ConversationsRepo, LocalgroupsRepo, VotesRepo } from '../repos';
import Localgroups from '../../lib/collections/localgroups/collection';
import { collectionsThatAffectKarma } from '../callbacks/votingCallbacks';
import { filterNonnull, filterWhereFieldsNotNull } from '../../lib/utils/typeGuardUtils';

const transferOwnership = async ({documentId, targetUserId, collection, fieldName = "userId"}: {
  documentId: string
  targetUserId: string
  collection: CollectionBase<any>
  fieldName: string
}) => {
  await updateMutator({
    collection,
    documentId,
    set: {[fieldName]: targetUserId},
    unset: {},
    validate: false,
  })
}

const transferCollection = async ({sourceUserId, targetUserId, collectionName, fieldName = "userId", dryRun}: {
  sourceUserId: string,
  targetUserId: string,
  collectionName: CollectionNameString,
  fieldName?: string,
  dryRun: boolean
}) => {
  const collection = getCollection(collectionName)

  try {
    const [sourceUserCount, targetUserCount] = await Promise.all([
      collection.find({[fieldName]: sourceUserId}).count(),
      collection.find({[fieldName]: targetUserId}).count(),
    ])
    // eslint-disable-next-line no-console
    console.log()
    // eslint-disable-next-line no-console
    console.log(`Source user ${sourceUserId} ${collectionName} count: ${sourceUserCount}`)
    // eslint-disable-next-line no-console
    console.log(`Target user ${targetUserId} ${collectionName} count: ${targetUserCount}`)

    if (!dryRun) {
      const documents = await collection.find({[fieldName]: sourceUserId}).fetch()
      // eslint-disable-next-line no-console
      console.log(`Transferring ${documents.length} documents in collection ${collectionName}`)
      for (const doc of documents) {
        try {
          await transferOwnership({documentId: doc._id, targetUserId, collection, fieldName})
          // Transfer ownership of all revisions and denormalized references for editable fields
          const editableFieldNames = editableCollectionsFields[collectionName]
          if (editableFieldNames?.length) {
            await asyncForeachSequential(editableFieldNames, async (editableFieldName) => {
              await transferEditableField({documentId: doc._id, sourceUserId, targetUserId, collection, fieldName: editableFieldName})
            })
          }
        } catch (err) {
          // eslint-disable-next-line no-console
          console.log("")
          // eslint-disable-next-line no-console
          console.log("%c Error Transferring Document", doc._id, collectionName, 'color: red')
          // eslint-disable-next-line no-console
          console.log(err)
        }
      }
      const finalTargetUserCount = await collection.find({[fieldName]: targetUserId}).count()
      // eslint-disable-next-line no-console
      console.log(`Final target user ${targetUserId} ${collectionName} count: ${finalTargetUserCount} (compare ${sourceUserCount + targetUserCount})`)
    }

  } catch (err) {
    // eslint-disable-next-line no-console
    console.log()
    // eslint-disable-next-line no-console
    console.log(`%c Error while transferring collection ${collectionName}`, "color: red")
    // eslint-disable-next-line no-console
    console.log(err)
  }
}

const transferEditableField = async ({documentId, sourceUserId, targetUserId, collection, fieldName = "contents"}: {
  documentId: string,
  sourceUserId: string,
  targetUserId: string,
  collection: CollectionBase<CollectionNameString>,
  fieldName: string
}) => {
  // Update the denormalized revision on the document
  await updateMutator({
    collection,
    documentId,
    set: {[`${fieldName}.userId`]: targetUserId},
    unset: {},
    validate: false
  })
  // Update the revisions themselves
  await Revisions.rawUpdateMany({ documentId, userId: sourceUserId, fieldName }, {$set: {userId: targetUserId}}, { multi: true })
}

type PostOrTagSelector = {postId: string} | {tagId: string}

const mergeReadStatus = async ({sourceUserId, targetUserId, postOrTagSelector}: {
  sourceUserId: string, 
  targetUserId: string, 
  postOrTagSelector: PostOrTagSelector
}) => {
  const sourceUserStatus = await ReadStatuses.findOne({userId: sourceUserId, ...postOrTagSelector})
  const targetUserStatus = await ReadStatuses.findOne({userId: targetUserId, ...postOrTagSelector})
  const sourceMostRecentlyUpdated = (sourceUserStatus && targetUserStatus) ? (new Date(sourceUserStatus.lastUpdated) > new Date(targetUserStatus.lastUpdated)) : !!sourceUserStatus
  const readStatus = sourceMostRecentlyUpdated ? sourceUserStatus?.isRead : targetUserStatus?.isRead
  const lastUpdated = sourceMostRecentlyUpdated ? sourceUserStatus?.lastUpdated : targetUserStatus?.lastUpdated
  if (targetUserStatus) {
    await ReadStatuses.rawUpdateOne({_id: targetUserStatus._id}, {$set: {isRead: readStatus, lastUpdated}})
  } else if (sourceUserStatus) {
    // eslint-disable-next-line no-unused-vars
    const {_id, ...sourceUserStatusWithoutId} = sourceUserStatus
    await ReadStatuses.rawInsert({...sourceUserStatusWithoutId, userId: targetUserId})
  }
}

const transferServices = async (sourceUser: DbUser, targetUser: DbUser, dryRun: boolean) => {
  // eslint-disable-next-line no-console
  console.log(`transferring services from ${sourceUser._id} to ${targetUser._id}`)

  // we copy services for github, facebook and google 
  const profilePaths = ["github", "facebook", "google"]

  for (const profilePath of profilePaths) {
    const sourceProfile = sourceUser.services[profilePath]
    if (sourceProfile && !targetUser.services[profilePath]) {
      // eslint-disable-next-line no-console
      console.log(`  Copying ${profilePath} profile from ${sourceUser._id} to ${targetUser._id}`)
      if (!dryRun) {

        // if we don't remove the profile from the old account, we'll get a duplicate key error
        await updateMutator({
          collection: Users,
          documentId: sourceUser._id,
          unset: {[`services.${profilePath}`]: null} as any,
          // Normal updates are not supposed to update services
          validate: false
        })
        await updateMutator({
          collection: Users,
          documentId: targetUser._id,
          set: {[`services.${profilePath}`]: sourceProfile} as any,
          // Normal updates are not supposed to update services
          validate: false
        })
      } 
    } else {
      // eslint-disable-next-line no-console
      console.log(`  Not copying ${profilePath}`)
    }
  }
}

Vulcan.mergeAccounts = async ({sourceUserId, targetUserId, dryRun}: {
  sourceUserId: string, 
  targetUserId: string, 
  dryRun: boolean
}) => {
  if (typeof dryRun !== "boolean") throw Error("dryRun value missing")

  const sourceUser = await Users.findOne({_id: sourceUserId})
  const targetUser = await Users.findOne({_id: targetUserId})
  if (!sourceUser) throw Error(`Can't find sourceUser with Id: ${sourceUserId}`)
  if (!targetUser) throw Error(`Can't find targetUser with Id: ${targetUserId}`)

  // DO NOT transfer LWEvents, there are way too many and they're probably not important after the fact
  // await transferCollection({sourceUserId, targetUserId, collectionName: "LWEvents"})

  // Do not transfer gardencodes, they aren't in use
  // We don't transfer revisions because that's handled by transferEditableField

  // Transfer bans
  await transferCollection({sourceUserId, targetUserId, collectionName: "Bans", dryRun})

  // Transfer subscriptions (i.e. email subscriptions)
  await transferCollection({sourceUserId, targetUserId, collectionName: "Subscriptions", dryRun})

  // Transfer posts
  await transferCollection({sourceUserId, targetUserId, collectionName: "Posts", dryRun})

  // Transfer comments
  await transferCollection({sourceUserId, targetUserId, collectionName: "Comments", dryRun})

  // Transfer user-created tags
  await transferCollection({sourceUserId, targetUserId, collectionName: "Tags", dryRun})

  // Transfer tag-post relationships (first user who voted on that tag for that post)
  await transferCollection({sourceUserId, targetUserId, collectionName: "TagRels", dryRun})

  // Transfer rss feeds (for crossposting)
  await transferCollection({sourceUserId, targetUserId, collectionName: "RSSFeeds", dryRun})

  // Transfer petrov day launches
  await transferCollection({sourceUserId, targetUserId, collectionName: "PetrovDayLaunchs", dryRun})

  // Transfer reports (i.e. user reporting a comment/tag/etc)
  await transferCollection({sourceUserId, targetUserId, collectionName: "Reports", dryRun})

  try {
    const [sourceConversationsCount, targetConversationsCount] = await Promise.all([
      Conversations.find({participantIds: sourceUserId}).count(),
      Conversations.find({participantIds: sourceUserId}).count()
    ])
    // eslint-disable-next-line no-console
    console.log(`conversations from source user: ${sourceConversationsCount}`)
    // eslint-disable-next-line no-console
    console.log(`conversations from target user: ${targetConversationsCount}`)

    if (!dryRun) {
      // Transfer conversations
      await new ConversationsRepo().moveUserConversationsToNewUser(sourceUserId, targetUserId);
    }
  } catch (err) {
    // eslint-disable-next-line no-console
    console.log()
    // eslint-disable-next-line no-console
    console.log("%c Error merging conversations", "color:red")
    // eslint-disable-next-line no-console
    console.log(err)
  }

  // Transfer private messages
  await transferCollection({sourceUserId, targetUserId, collectionName: "Messages", dryRun})

  // Transfer notifications
  await transferCollection({sourceUserId, targetUserId, collectionName: "Notifications", dryRun})

  try {
    const readStatuses = await ReadStatuses.find({userId: sourceUserId}).fetch()
    const readPostIds = filterNonnull(readStatuses.map((status) => status.postId))
    const readTagIds = filterNonnull(readStatuses.map((status) => status.tagId))
    // eslint-disable-next-line no-console
    console.log(`source readPostIds count: ${readPostIds.length}`)
    // eslint-disable-next-line no-console
    console.log(`source readTagIds count: ${readTagIds.length}`)
    if (!dryRun) {
      // Transfer readStatuses
      await asyncForeachSequential(readPostIds, async (postId) => {
        await mergeReadStatus({sourceUserId, targetUserId, postOrTagSelector:{postId}})
      })
      await asyncForeachSequential(readTagIds, async (tagId) => {
        await mergeReadStatus({sourceUserId, targetUserId, postOrTagSelector:{tagId}})
      })
    }
  } catch (err) {
    // eslint-disable-next-line no-console
    console.log()
    // eslint-disable-next-line no-console
    console.log("%c Error merging readStatuses", "color: red")
    // eslint-disable-next-line no-console
    console.log(err)
  }

  // Transfer sequences
  await transferCollection({sourceUserId, targetUserId, collectionName: "Sequences", dryRun})
  await transferCollection({sourceUserId, targetUserId, collectionName: "Collections", dryRun})

  // Transfer localgroups
  if (!dryRun) {
    await new LocalgroupsRepo().moveUserLocalgroupsToNewUser(sourceUserId, targetUserId);
  }

  // Transfer review votes
  await transferCollection({sourceUserId, targetUserId, collectionName: "ReviewVotes", dryRun})
  
  try {
    const [authorVotesCount, userVoteCounts] = await Promise.all([
      Votes.find({authorIds: sourceUserId}).count(),
      Votes.find({userId: sourceUserId}).count()
    ]) 
    // eslint-disable-next-line no-console
    console.log(`authorVotesCount: ${authorVotesCount}`)
    // eslint-disable-next-line no-console
    console.log(`userVoteCounts: ${userVoteCounts}`)
    if (!dryRun) {
      // Transfer votes that target content from source user (authorId)
      // eslint-disable-next-line no-console
      console.log("Transferring votes that target source user")
      await new VotesRepo().transferVotesTargetingUser(sourceUserId, targetUserId);

      // Transfer votes cast by source user
      // eslint-disable-next-line no-console
      console.log("Transferring votes cast by source user")
      await Votes.rawUpdateMany({userId: sourceUserId}, {$set: {userId: targetUserId}}, {multi: true})
  
      // Transfer karma
      // eslint-disable-next-line no-console
      console.log("Transferring karma")
      const newKarma = await recomputeKarma(targetUserId)
      await updateMutator({
        collection: Users,
        documentId: targetUserId,
        set: {
          karma: newKarma, 
          // We only recalculate the karma for non-af karma, because recalculating
          // af karma is a lot more complicated
          afKarma: (sourceUser.afKarma) + (targetUser.afKarma)
        },
        validate: false
      })
    }    
  } catch (err) {
    // eslint-disable-next-line no-console
    console.log()
    // eslint-disable-next-line no-console
    console.log("%c Error merging votes", "color: red")
    // eslint-disable-next-line no-console
    console.log(err)
  }

  await transferServices(sourceUser, targetUser, dryRun)
  
  // Change slug of source account by appending "old" and reset oldSlugs array
  // eslint-disable-next-line no-console
  console.log("Change slugs of source account")
  try {

    if (!dryRun) {
      await Users.rawUpdateOne(
        {_id: sourceUserId},
        {$set: {
          slug: await Utils.getUnusedSlug(Users, `${sourceUser.slug}-old`, true)
        }}
      );
    
      // Add slug to oldSlugs array of target account
      const newOldSlugs = [
        ...(targetUser.oldSlugs || []), 
        ...(sourceUser.oldSlugs || []), 
        sourceUser.slug
      ]
      // eslint-disable-next-line no-console
      console.log("Changing slugs of target account", sourceUser.slug, newOldSlugs)
      
      await updateMutator({
        collection: Users,
        documentId: targetUserId,
        set: {oldSlugs: filterNonnull(newOldSlugs)}, 
        validate: false
      })
    }
  } catch (err) {
    // eslint-disable-next-line no-console
    console.log("%c Error changing slugs", "color: red")
    // eslint-disable-next-line no-console
    console.log(err)
  }

  // if the two accounts share an email address, change the sourceUser email to "+old"
  try {
    if (!dryRun && !!sourceUser.email && !!targetUser.email) {
      const splitEmail = sourceUser.email.split("@")
      const newEmail = `${splitEmail[0]}+old@${splitEmail[1]}` 
      if (sourceUser.email === targetUser.email) {
        // appending "+old" should still allow the email to work if need be
        await Users.rawUpdateOne(
          {_id: sourceUserId},
          {$set: {
            email: newEmail
          }}
        );
      }

      if ((sourceUser?.emails) && (targetUser?.emails)) {
        const sourceEmailsEmail = sourceUser.emails.length > 0 && sourceUser.emails[0]
        const targetEmailsEmail = targetUser.email.length > 0 && targetUser.emails[0]

        if (sourceEmailsEmail === targetEmailsEmail) {
          await Users.rawUpdateOne(
            {_id: sourceUserId},
            {$set: {
              'emails.0': {address: newEmail, verified: sourceEmailsEmail ? sourceEmailsEmail.verified : false}
            }}
          );
        }
      }
    }
  } catch (err) {
    // eslint-disable-next-line no-console
    console.log("%c Error changing emails", "color: red")
    // eslint-disable-next-line no-console
    console.log(err)
  }

  // if the two accounts share a displayName, change the sourceUSer to " (Old)"
  try {
    if (!dryRun) {
      if (sourceUser.displayName === targetUser.displayName) {
        const newDisplayName = sourceUser.displayName + " (Old)"
        await Users.rawUpdateOne({_id: sourceUserId}, {$set: { email: newDisplayName}}
        );
      }
    }
  } catch (err) {
    // eslint-disable-next-line no-console
    console.log("%c Error changing displayName", "color: red")
    // eslint-disable-next-line no-console
    console.log(err)
  }

  // Transfer email tokens
  await transferCollection({sourceUserId, targetUserId, collectionName: "EmailTokens", dryRun})
  
  if (!dryRun) {
    // Mark old acccount as deleted
    // eslint-disable-next-line no-console
    console.log("Marking old account as deleted")
    await updateMutator({
      collection: Users,
      documentId: sourceUserId,
      set: {
        deleted: true
      },
      // We remove the login tokins from the source account since it's now deleted
      unset: {'services.resume':1},
      validate: false
    })
  }
}


async function recomputeKarma(userId: string) {
  const user = await Users.findOne({_id: userId})
  if (!user) throw Error("Can't find user")
  const selector: Record<string, any> = {
    authorIds: user._id,
    userId: {$ne: user._id},
    cancelled: false,
    collectionName: {$in: collectionsThatAffectKarma}
  };
  const rawAllTargetVotes = await Votes.find(selector).fetch()
  const allTargetVotes = filterWhereFieldsNotNull(rawAllTargetVotes, "authorIds")
  const karma = sumBy(allTargetVotes, vote => {
    // a doc author cannot give karma to themselves or any other authors for that doc
    return vote.authorIds.includes(vote.userId) ? 0 : vote.power
  })
  return karma
}

Vulcan.getTotalKarmaForUser = recomputeKarma

1	import Users from '../../lib/collections/users/collection';	18✔
2	import { Vulcan, updateMutator, getCollection, Utils } from '../vulcan-lib';	18✔
3	import { Revisions } from '../../lib/collections/revisions/collection';	18✔
4	import { editableCollectionsFields } from '../../lib/editor/make_editable'	18✔
5	import ReadStatuses from '../../lib/collections/readStatus/collection';	18✔
6	import { Votes } from '../../lib/collections/votes/index';	18✔
7	import { Conversations } from '../../lib/collections/conversations/collection'	18✔
8	import { asyncForeachSequential } from '../../lib/utils/asyncUtils';	18✔
9	import sumBy from 'lodash/sumBy';	18✔
10	import { ConversationsRepo, LocalgroupsRepo, VotesRepo } from '../repos';	18✔
11	import Localgroups from '../../lib/collections/localgroups/collection';
12	import { collectionsThatAffectKarma } from '../callbacks/votingCallbacks';	18✔
13	import { filterNonnull, filterWhereFieldsNotNull } from '../../lib/utils/typeGuardUtils';	18✔
14
15	const transferOwnership = async ({documentId, targetUserId, collection, fieldName = "userId"}: {	18!
16	documentId: string
17	targetUserId: string
18	collection: CollectionBase<any>
19	fieldName: string
20	}) => {
21	await updateMutator({	×
22	collection,
23	documentId,
24	set: {[fieldName]: targetUserId},
25	unset: {},
26	validate: false,
27	})
28	}
29
30	const transferCollection = async ({sourceUserId, targetUserId, collectionName, fieldName = "userId", dryRun}: {	18!
31	sourceUserId: string,
32	targetUserId: string,
33	collectionName: CollectionNameString,
34	fieldName?: string,
35	dryRun: boolean
36	}) => {
37	const collection = getCollection(collectionName)	×
38
39	try {	×
40	const [sourceUserCount, targetUserCount] = await Promise.all([	×
41	collection.find({[fieldName]: sourceUserId}).count(),
42	collection.find({[fieldName]: targetUserId}).count(),
43	])
44	// eslint-disable-next-line no-console
45	console.log()	×
46	// eslint-disable-next-line no-console
47	console.log(`Source user ${sourceUserId} ${collectionName} count: ${sourceUserCount}`)	×
48	// eslint-disable-next-line no-console
49	console.log(`Target user ${targetUserId} ${collectionName} count: ${targetUserCount}`)	×
50
51	if (!dryRun) {	×
52	const documents = await collection.find({[fieldName]: sourceUserId}).fetch()	×
53	// eslint-disable-next-line no-console
54	console.log(`Transferring ${documents.length} documents in collection ${collectionName}`)	×
55	for (const doc of documents) {	×
56	try {	×
57	await transferOwnership({documentId: doc._id, targetUserId, collection, fieldName})	×
58	// Transfer ownership of all revisions and denormalized references for editable fields
59	const editableFieldNames = editableCollectionsFields[collectionName]	×
60	if (editableFieldNames?.length) {	×
61	await asyncForeachSequential(editableFieldNames, async (editableFieldName) => {	×
62	await transferEditableField({documentId: doc._id, sourceUserId, targetUserId, collection, fieldName: editableFieldName})	×
63	})
64	}
65	} catch (err) {
66	// eslint-disable-next-line no-console
67	console.log("")	×
68	// eslint-disable-next-line no-console
69	console.log("%c Error Transferring Document", doc._id, collectionName, 'color: red')	×
70	// eslint-disable-next-line no-console
71	console.log(err)	×
72	}
73	}
74	const finalTargetUserCount = await collection.find({[fieldName]: targetUserId}).count()	×
75	// eslint-disable-next-line no-console
76	console.log(`Final target user ${targetUserId} ${collectionName} count: ${finalTargetUserCount} (compare ${sourceUserCount + targetUserCount})`)	×
77	}
78
79	} catch (err) {
80	// eslint-disable-next-line no-console
81	console.log()	×
82	// eslint-disable-next-line no-console
83	console.log(`%c Error while transferring collection ${collectionName}`, "color: red")	×
84	// eslint-disable-next-line no-console
85	console.log(err)	×
86	}
87	}
88
89	const transferEditableField = async ({documentId, sourceUserId, targetUserId, collection, fieldName = "contents"}: {	18!
90	documentId: string,
91	sourceUserId: string,
92	targetUserId: string,
93	collection: CollectionBase<CollectionNameString>,
94	fieldName: string
95	}) => {
96	// Update the denormalized revision on the document
97	await updateMutator({	×
98	collection,
99	documentId,
100	set: {[`${fieldName}.userId`]: targetUserId},
101	unset: {},
102	validate: false
103	})
104	// Update the revisions themselves
105	await Revisions.rawUpdateMany({ documentId, userId: sourceUserId, fieldName }, {$set: {userId: targetUserId}}, { multi: true })	×
106	}
107
108	type PostOrTagSelector = {postId: string} \| {tagId: string}
109
110	const mergeReadStatus = async ({sourceUserId, targetUserId, postOrTagSelector}: {	18✔
111	sourceUserId: string,
112	targetUserId: string,
113	postOrTagSelector: PostOrTagSelector
114	}) => {
115	const sourceUserStatus = await ReadStatuses.findOne({userId: sourceUserId, ...postOrTagSelector})	×
116	const targetUserStatus = await ReadStatuses.findOne({userId: targetUserId, ...postOrTagSelector})	×
117	const sourceMostRecentlyUpdated = (sourceUserStatus && targetUserStatus) ? (new Date(sourceUserStatus.lastUpdated) > new Date(targetUserStatus.lastUpdated)) : !!sourceUserStatus	×
118	const readStatus = sourceMostRecentlyUpdated ? sourceUserStatus?.isRead : targetUserStatus?.isRead	×
119	const lastUpdated = sourceMostRecentlyUpdated ? sourceUserStatus?.lastUpdated : targetUserStatus?.lastUpdated	×
120	if (targetUserStatus) {	×
121	await ReadStatuses.rawUpdateOne({_id: targetUserStatus._id}, {$set: {isRead: readStatus, lastUpdated}})	×
122	} else if (sourceUserStatus) {	×
123	// eslint-disable-next-line no-unused-vars
124	const {_id, ...sourceUserStatusWithoutId} = sourceUserStatus	×
125	await ReadStatuses.rawInsert({...sourceUserStatusWithoutId, userId: targetUserId})	×
126	}
127	}
128
129	const transferServices = async (sourceUser: DbUser, targetUser: DbUser, dryRun: boolean) => {	18✔
130	// eslint-disable-next-line no-console
131	console.log(`transferring services from ${sourceUser._id} to ${targetUser._id}`)	×
132
133	// we copy services for github, facebook and google
134	const profilePaths = ["github", "facebook", "google"]	×
135
136	for (const profilePath of profilePaths) {	×
137	const sourceProfile = sourceUser.services[profilePath]	×
138	if (sourceProfile && !targetUser.services[profilePath]) {	×
139	// eslint-disable-next-line no-console
140	console.log(` Copying ${profilePath} profile from ${sourceUser._id} to ${targetUser._id}`)	×
141	if (!dryRun) {	×
142
143	// if we don't remove the profile from the old account, we'll get a duplicate key error
144	await updateMutator({	×
145	collection: Users,
146	documentId: sourceUser._id,
147	unset: {[`services.${profilePath}`]: null} as any,
148	// Normal updates are not supposed to update services
149	validate: false
150	})
151	await updateMutator({	×
152	collection: Users,
153	documentId: targetUser._id,
154	set: {[`services.${profilePath}`]: sourceProfile} as any,
155	// Normal updates are not supposed to update services
156	validate: false
157	})
158	}
159	} else {
160	// eslint-disable-next-line no-console
161	console.log(` Not copying ${profilePath}`)	×
162	}
163	}
164	}
165
166	Vulcan.mergeAccounts = async ({sourceUserId, targetUserId, dryRun}: {	18✔
167	sourceUserId: string,
168	targetUserId: string,
169	dryRun: boolean
170	}) => {
171	if (typeof dryRun !== "boolean") throw Error("dryRun value missing")	×
172
173	const sourceUser = await Users.findOne({_id: sourceUserId})	×
174	const targetUser = await Users.findOne({_id: targetUserId})	×
175	if (!sourceUser) throw Error(`Can't find sourceUser with Id: ${sourceUserId}`)	×
176	if (!targetUser) throw Error(`Can't find targetUser with Id: ${targetUserId}`)	×
177
178	// DO NOT transfer LWEvents, there are way too many and they're probably not important after the fact
179	// await transferCollection({sourceUserId, targetUserId, collectionName: "LWEvents"})
180
181	// Do not transfer gardencodes, they aren't in use
182	// We don't transfer revisions because that's handled by transferEditableField
183
184	// Transfer bans
185	await transferCollection({sourceUserId, targetUserId, collectionName: "Bans", dryRun})	×
186
187	// Transfer subscriptions (i.e. email subscriptions)
188	await transferCollection({sourceUserId, targetUserId, collectionName: "Subscriptions", dryRun})	×
189
190	// Transfer posts
191	await transferCollection({sourceUserId, targetUserId, collectionName: "Posts", dryRun})	×
192
193	// Transfer comments
194	await transferCollection({sourceUserId, targetUserId, collectionName: "Comments", dryRun})	×
195
196	// Transfer user-created tags
UNCOV 197	await transferCollection({sourceUserId, targetUserId, collectionName: "Tags", dryRun})	×
198
199	// Transfer tag-post relationships (first user who voted on that tag for that post)
UNCOV 200	await transferCollection({sourceUserId, targetUserId, collectionName: "TagRels", dryRun})	×
201
202	// Transfer rss feeds (for crossposting)
UNCOV 203	await transferCollection({sourceUserId, targetUserId, collectionName: "RSSFeeds", dryRun})	×
204
205	// Transfer petrov day launches
UNCOV 206	await transferCollection({sourceUserId, targetUserId, collectionName: "PetrovDayLaunchs", dryRun})	×
207
208	// Transfer reports (i.e. user reporting a comment/tag/etc)
UNCOV 209	await transferCollection({sourceUserId, targetUserId, collectionName: "Reports", dryRun})	×
210
UNCOV 211	try {	×
UNCOV 212	const [sourceConversationsCount, targetConversationsCount] = await Promise.all([	×
213	Conversations.find({participantIds: sourceUserId}).count(),
214	Conversations.find({participantIds: sourceUserId}).count()
215	])
216	// eslint-disable-next-line no-console
UNCOV 217	console.log(`conversations from source user: ${sourceConversationsCount}`)	×
218	// eslint-disable-next-line no-console
219	console.log(`conversations from target user: ${targetConversationsCount}`)	×
220
UNCOV 221	if (!dryRun) {	×
222	// Transfer conversations
UNCOV 223	await new ConversationsRepo().moveUserConversationsToNewUser(sourceUserId, targetUserId);	×
224	}
225	} catch (err) {
226	// eslint-disable-next-line no-console
UNCOV 227	console.log()	×
228	// eslint-disable-next-line no-console
UNCOV 229	console.log("%c Error merging conversations", "color:red")	×
230	// eslint-disable-next-line no-console
UNCOV 231	console.log(err)	×
232	}
233
234	// Transfer private messages
UNCOV 235	await transferCollection({sourceUserId, targetUserId, collectionName: "Messages", dryRun})	×
236
237	// Transfer notifications
UNCOV 238	await transferCollection({sourceUserId, targetUserId, collectionName: "Notifications", dryRun})	×
239
240	try {	×
UNCOV 241	const readStatuses = await ReadStatuses.find({userId: sourceUserId}).fetch()	×
242	const readPostIds = filterNonnull(readStatuses.map((status) => status.postId))	×
UNCOV 243	const readTagIds = filterNonnull(readStatuses.map((status) => status.tagId))	×
244	// eslint-disable-next-line no-console
UNCOV 245	console.log(`source readPostIds count: ${readPostIds.length}`)	×
246	// eslint-disable-next-line no-console
UNCOV 247	console.log(`source readTagIds count: ${readTagIds.length}`)	×
248	if (!dryRun) {	×
249	// Transfer readStatuses
UNCOV 250	await asyncForeachSequential(readPostIds, async (postId) => {	×
251	await mergeReadStatus({sourceUserId, targetUserId, postOrTagSelector:{postId}})	×
252	})
253	await asyncForeachSequential(readTagIds, async (tagId) => {	×
254	await mergeReadStatus({sourceUserId, targetUserId, postOrTagSelector:{tagId}})	×
255	})
256	}
257	} catch (err) {
258	// eslint-disable-next-line no-console
UNCOV 259	console.log()	×
260	// eslint-disable-next-line no-console
261	console.log("%c Error merging readStatuses", "color: red")	×
262	// eslint-disable-next-line no-console
263	console.log(err)	×
264	}
265
266	// Transfer sequences
267	await transferCollection({sourceUserId, targetUserId, collectionName: "Sequences", dryRun})	×
UNCOV 268	await transferCollection({sourceUserId, targetUserId, collectionName: "Collections", dryRun})	×
269
270	// Transfer localgroups
UNCOV 271	if (!dryRun) {	×
272	await new LocalgroupsRepo().moveUserLocalgroupsToNewUser(sourceUserId, targetUserId);	×
273	}
274
275	// Transfer review votes
276	await transferCollection({sourceUserId, targetUserId, collectionName: "ReviewVotes", dryRun})	×
277
UNCOV 278	try {	×
UNCOV 279	const [authorVotesCount, userVoteCounts] = await Promise.all([	×
280	Votes.find({authorIds: sourceUserId}).count(),
281	Votes.find({userId: sourceUserId}).count()
282	])
283	// eslint-disable-next-line no-console
284	console.log(`authorVotesCount: ${authorVotesCount}`)	×
285	// eslint-disable-next-line no-console
UNCOV 286	console.log(`userVoteCounts: ${userVoteCounts}`)	×
UNCOV 287	if (!dryRun) {	×
288	// Transfer votes that target content from source user (authorId)
289	// eslint-disable-next-line no-console
UNCOV 290	console.log("Transferring votes that target source user")	×
291	await new VotesRepo().transferVotesTargetingUser(sourceUserId, targetUserId);	×
292
293	// Transfer votes cast by source user
294	// eslint-disable-next-line no-console
UNCOV 295	console.log("Transferring votes cast by source user")	×
UNCOV 296	await Votes.rawUpdateMany({userId: sourceUserId}, {$set: {userId: targetUserId}}, {multi: true})	×
297
298	// Transfer karma
299	// eslint-disable-next-line no-console
300	console.log("Transferring karma")	×
UNCOV 301	const newKarma = await recomputeKarma(targetUserId)	×
UNCOV 302	await updateMutator({	×
303	collection: Users,
304	documentId: targetUserId,
305	set: {
306	karma: newKarma,
307	// We only recalculate the karma for non-af karma, because recalculating
308	// af karma is a lot more complicated
309	afKarma: (sourceUser.afKarma) + (targetUser.afKarma)
310	},
311	validate: false
312	})
313	}
314	} catch (err) {
315	// eslint-disable-next-line no-console
UNCOV 316	console.log()	×
317	// eslint-disable-next-line no-console
UNCOV 318	console.log("%c Error merging votes", "color: red")	×
319	// eslint-disable-next-line no-console
UNCOV 320	console.log(err)	×
321	}
322
UNCOV 323	await transferServices(sourceUser, targetUser, dryRun)	×
324
325	// Change slug of source account by appending "old" and reset oldSlugs array
326	// eslint-disable-next-line no-console
UNCOV 327	console.log("Change slugs of source account")	×
UNCOV 328	try {	×
329
UNCOV 330	if (!dryRun) {	×
331	await Users.rawUpdateOne(	×
332	{_id: sourceUserId},
333	{$set: {
334	slug: await Utils.getUnusedSlug(Users, `${sourceUser.slug}-old`, true)
335	}}
336	);
337
338	// Add slug to oldSlugs array of target account
UNCOV 339	const newOldSlugs = [	×
340	...(targetUser.oldSlugs \|\| []),	×
341	...(sourceUser.oldSlugs \|\| []),	×
342	sourceUser.slug
343	]
344	// eslint-disable-next-line no-console
UNCOV 345	console.log("Changing slugs of target account", sourceUser.slug, newOldSlugs)	×
346
UNCOV 347	await updateMutator({	×
348	collection: Users,
349	documentId: targetUserId,
350	set: {oldSlugs: filterNonnull(newOldSlugs)},
351	validate: false
352	})
353	}
354	} catch (err) {
355	// eslint-disable-next-line no-console
UNCOV 356	console.log("%c Error changing slugs", "color: red")	×
357	// eslint-disable-next-line no-console
358	console.log(err)	×
359	}
360
361	// if the two accounts share an email address, change the sourceUser email to "+old"
UNCOV 362	try {	×
UNCOV 363	if (!dryRun && !!sourceUser.email && !!targetUser.email) {	×
UNCOV 364	const splitEmail = sourceUser.email.split("@")	×
UNCOV 365	const newEmail = `${splitEmail[0]}+old@${splitEmail[1]}`	×
UNCOV 366	if (sourceUser.email === targetUser.email) {	×
367	// appending "+old" should still allow the email to work if need be
UNCOV 368	await Users.rawUpdateOne(	×
369	{_id: sourceUserId},
370	{$set: {
371	email: newEmail
372	}}
373	);
374	}
375
376	if ((sourceUser?.emails) && (targetUser?.emails)) {	×
377	const sourceEmailsEmail = sourceUser.emails.length > 0 && sourceUser.emails[0]	×
378	const targetEmailsEmail = targetUser.email.length > 0 && targetUser.emails[0]	×
379
UNCOV 380	if (sourceEmailsEmail === targetEmailsEmail) {	×
381	await Users.rawUpdateOne(	×
382	{_id: sourceUserId},
383	{$set: {
384	'emails.0': {address: newEmail, verified: sourceEmailsEmail ? sourceEmailsEmail.verified : false}	×
385	}}
386	);
387	}
388	}
389	}
390	} catch (err) {
391	// eslint-disable-next-line no-console
UNCOV 392	console.log("%c Error changing emails", "color: red")	×
393	// eslint-disable-next-line no-console
394	console.log(err)	×
395	}
396
397	// if the two accounts share a displayName, change the sourceUSer to " (Old)"
UNCOV 398	try {	×
UNCOV 399	if (!dryRun) {	×
UNCOV 400	if (sourceUser.displayName === targetUser.displayName) {	×
UNCOV 401	const newDisplayName = sourceUser.displayName + " (Old)"	×
UNCOV 402	await Users.rawUpdateOne({_id: sourceUserId}, {$set: { email: newDisplayName}}	×
403	);
404	}
405	}
406	} catch (err) {
407	// eslint-disable-next-line no-console
UNCOV 408	console.log("%c Error changing displayName", "color: red")	×
409	// eslint-disable-next-line no-console
UNCOV 410	console.log(err)	×
411	}
412
413	// Transfer email tokens
414	await transferCollection({sourceUserId, targetUserId, collectionName: "EmailTokens", dryRun})	×
415
UNCOV 416	if (!dryRun) {	×
417	// Mark old acccount as deleted
418	// eslint-disable-next-line no-console
UNCOV 419	console.log("Marking old account as deleted")	×
UNCOV 420	await updateMutator({	×
421	collection: Users,
422	documentId: sourceUserId,
423	set: {
424	deleted: true
425	},
426	// We remove the login tokins from the source account since it's now deleted
427	unset: {'services.resume':1},
428	validate: false
429	})
430	}
431	}
432
433
434	async function recomputeKarma(userId: string) {
UNCOV 435	const user = await Users.findOne({_id: userId})	×
UNCOV 436	if (!user) throw Error("Can't find user")	×
UNCOV 437	const selector: Record<string, any> = {	×
438	authorIds: user._id,
439	userId: {$ne: user._id},
440	cancelled: false,
441	collectionName: {$in: collectionsThatAffectKarma}
442	};
UNCOV 443	const rawAllTargetVotes = await Votes.find(selector).fetch()	×
UNCOV 444	const allTargetVotes = filterWhereFieldsNotNull(rawAllTargetVotes, "authorIds")	×
UNCOV 445	const karma = sumBy(allTargetVotes, vote => {	×
446	// a doc author cannot give karma to themselves or any other authors for that doc
UNCOV 447	return vote.authorIds.includes(vote.userId) ? 0 : vote.power	×
448	})
449	return karma	×
450	}
451
452	Vulcan.getTotalKarmaForUser = recomputeKarma	18✔

ForumMagnum / ForumMagnum / 9022431366

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