8929626656

Committed 02 May 2024 07:50PM UTC coverage: 31.87% (-0.05%) from 31.923%

Build # 8929626656

Build Type

push

github

Committed by

s-cheng

Commit Message

update merge accounts script

Run Details

4729 of 38736 branches covered (12.21%)

Branch coverage included in aggregate %.

11 of 17 new or added lines in 3 files covered. (64.71%)

1 existing line in 1 file now uncovered.

27580 of 62640 relevant lines covered (44.03%)

178.31 hits per line

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

7.25

/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, PostsRepo, 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 post co-authorship
  if (!dryRun) {
    await new PostsRepo().moveCoauthorshipToNewUser(sourceUserId, targetUserId)
  }

  // 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})
  
  // Transfer election votes
  await transferCollection({sourceUserId, targetUserId, collectionName: "ElectionVotes", dryRun})
  
  // Transfer moderator actions
  await transferCollection({sourceUserId, targetUserId, collectionName: "ModeratorActions", dryRun})
  
  // Transfer user rate limits
  await transferCollection({sourceUserId, targetUserId, collectionName: "UserRateLimits", dryRun})

  try {
    const [sourceConversationsCount, targetConversationsCount] = await Promise.all([
      Conversations.find({participantIds: sourceUserId}).count(),
      Conversations.find({participantIds: targetUserId}).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, PostsRepo, 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	// Transfer post co-authorship
NEW 193	if (!dryRun) {	×
NEW 194	await new PostsRepo().moveCoauthorshipToNewUser(sourceUserId, targetUserId)	×
195	}
196
197	// Transfer comments
198	await transferCollection({sourceUserId, targetUserId, collectionName: "Comments", dryRun})	×
199
200	// Transfer user-created tags
201	await transferCollection({sourceUserId, targetUserId, collectionName: "Tags", dryRun})	×
202
203	// Transfer tag-post relationships (first user who voted on that tag for that post)
204	await transferCollection({sourceUserId, targetUserId, collectionName: "TagRels", dryRun})	×
205
206	// Transfer rss feeds (for crossposting)
207	await transferCollection({sourceUserId, targetUserId, collectionName: "RSSFeeds", dryRun})	×
208
209	// Transfer petrov day launches
210	await transferCollection({sourceUserId, targetUserId, collectionName: "PetrovDayLaunchs", dryRun})	×
211
212	// Transfer reports (i.e. user reporting a comment/tag/etc)
213	await transferCollection({sourceUserId, targetUserId, collectionName: "Reports", dryRun})	×
214
215	// Transfer election votes
NEW 216	await transferCollection({sourceUserId, targetUserId, collectionName: "ElectionVotes", dryRun})	×
217
218	// Transfer moderator actions
NEW 219	await transferCollection({sourceUserId, targetUserId, collectionName: "ModeratorActions", dryRun})	×
220
221	// Transfer user rate limits
NEW 222	await transferCollection({sourceUserId, targetUserId, collectionName: "UserRateLimits", dryRun})	×
223
224	try {	×
225	const [sourceConversationsCount, targetConversationsCount] = await Promise.all([	×
226	Conversations.find({participantIds: sourceUserId}).count(),
227	Conversations.find({participantIds: targetUserId}).count()
228	])
229	// eslint-disable-next-line no-console
230	console.log(`conversations from source user: ${sourceConversationsCount}`)	×
231	// eslint-disable-next-line no-console
232	console.log(`conversations from target user: ${targetConversationsCount}`)	×
233
234	if (!dryRun) {	×
235	// Transfer conversations
236	await new ConversationsRepo().moveUserConversationsToNewUser(sourceUserId, targetUserId);	×
237	}
238	} catch (err) {
239	// eslint-disable-next-line no-console
240	console.log()	×
241	// eslint-disable-next-line no-console
242	console.log("%c Error merging conversations", "color:red")	×
243	// eslint-disable-next-line no-console
244	console.log(err)	×
245	}
246
247	// Transfer private messages
248	await transferCollection({sourceUserId, targetUserId, collectionName: "Messages", dryRun})	×
249
250	// Transfer notifications
251	await transferCollection({sourceUserId, targetUserId, collectionName: "Notifications", dryRun})	×
252
253	try {	×
254	const readStatuses = await ReadStatuses.find({userId: sourceUserId}).fetch()	×
255	const readPostIds = filterNonnull(readStatuses.map((status) => status.postId))	×
256	const readTagIds = filterNonnull(readStatuses.map((status) => status.tagId))	×
257	// eslint-disable-next-line no-console
258	console.log(`source readPostIds count: ${readPostIds.length}`)	×
259	// eslint-disable-next-line no-console
260	console.log(`source readTagIds count: ${readTagIds.length}`)	×
261	if (!dryRun) {	×
262	// Transfer readStatuses
263	await asyncForeachSequential(readPostIds, async (postId) => {	×
264	await mergeReadStatus({sourceUserId, targetUserId, postOrTagSelector:{postId}})	×
265	})
266	await asyncForeachSequential(readTagIds, async (tagId) => {	×
267	await mergeReadStatus({sourceUserId, targetUserId, postOrTagSelector:{tagId}})	×
268	})
269	}
270	} catch (err) {
271	// eslint-disable-next-line no-console
272	console.log()	×
273	// eslint-disable-next-line no-console
274	console.log("%c Error merging readStatuses", "color: red")	×
275	// eslint-disable-next-line no-console
276	console.log(err)	×
277	}
278
279	// Transfer sequences
280	await transferCollection({sourceUserId, targetUserId, collectionName: "Sequences", dryRun})	×
281	await transferCollection({sourceUserId, targetUserId, collectionName: "Collections", dryRun})	×
282
283	// Transfer localgroups
284	if (!dryRun) {	×
285	await new LocalgroupsRepo().moveUserLocalgroupsToNewUser(sourceUserId, targetUserId);	×
286	}
287
288	// Transfer review votes
289	await transferCollection({sourceUserId, targetUserId, collectionName: "ReviewVotes", dryRun})	×
290
291	try {	×
292	const [authorVotesCount, userVoteCounts] = await Promise.all([	×
293	Votes.find({authorIds: sourceUserId}).count(),
294	Votes.find({userId: sourceUserId}).count()
295	])
296	// eslint-disable-next-line no-console
297	console.log(`authorVotesCount: ${authorVotesCount}`)	×
298	// eslint-disable-next-line no-console
299	console.log(`userVoteCounts: ${userVoteCounts}`)	×
300	if (!dryRun) {	×
301	// Transfer votes that target content from source user (authorId)
302	// eslint-disable-next-line no-console
303	console.log("Transferring votes that target source user")	×
304	await new VotesRepo().transferVotesTargetingUser(sourceUserId, targetUserId);	×
305
306	// Transfer votes cast by source user
307	// eslint-disable-next-line no-console
308	console.log("Transferring votes cast by source user")	×
309	await Votes.rawUpdateMany({userId: sourceUserId}, {$set: {userId: targetUserId}}, {multi: true})	×
310
311	// Transfer karma
312	// eslint-disable-next-line no-console
313	console.log("Transferring karma")	×
314	const newKarma = await recomputeKarma(targetUserId)	×
315	await updateMutator({	×
316	collection: Users,
317	documentId: targetUserId,
318	set: {
319	karma: newKarma,
320	// We only recalculate the karma for non-af karma, because recalculating
321	// af karma is a lot more complicated
322	afKarma: (sourceUser.afKarma) + (targetUser.afKarma)
323	},
324	validate: false
325	})
326	}
327	} catch (err) {
328	// eslint-disable-next-line no-console
329	console.log()	×
330	// eslint-disable-next-line no-console
331	console.log("%c Error merging votes", "color: red")	×
332	// eslint-disable-next-line no-console
333	console.log(err)	×
334	}
335
336	await transferServices(sourceUser, targetUser, dryRun)	×
337
338	// Change slug of source account by appending "old" and reset oldSlugs array
339	// eslint-disable-next-line no-console
340	console.log("Change slugs of source account")	×
341	try {	×
342
343	if (!dryRun) {	×
344	await Users.rawUpdateOne(	×
345	{_id: sourceUserId},
346	{$set: {
347	slug: await Utils.getUnusedSlug(Users, `${sourceUser.slug}-old`, true)
348	}}
349	);
350
351	// Add slug to oldSlugs array of target account
352	const newOldSlugs = [	×
353	...(targetUser.oldSlugs \|\| []),	×
354	...(sourceUser.oldSlugs \|\| []),	×
355	sourceUser.slug
356	]
357	// eslint-disable-next-line no-console
358	console.log("Changing slugs of target account", sourceUser.slug, newOldSlugs)	×
359
360	await updateMutator({	×
361	collection: Users,
362	documentId: targetUserId,
363	set: {oldSlugs: filterNonnull(newOldSlugs)},
364	validate: false
365	})
366	}
367	} catch (err) {
368	// eslint-disable-next-line no-console
369	console.log("%c Error changing slugs", "color: red")	×
370	// eslint-disable-next-line no-console
371	console.log(err)	×
372	}
373
374	// if the two accounts share an email address, change the sourceUser email to "+old"
375	try {	×
376	if (!dryRun && !!sourceUser.email && !!targetUser.email) {	×
377	const splitEmail = sourceUser.email.split("@")	×
378	const newEmail = `${splitEmail[0]}+old@${splitEmail[1]}`	×
379	if (sourceUser.email === targetUser.email) {	×
380	// appending "+old" should still allow the email to work if need be
381	await Users.rawUpdateOne(	×
382	{_id: sourceUserId},
383	{$set: {
384	email: newEmail
385	}}
386	);
387	}
388
389	if ((sourceUser?.emails) && (targetUser?.emails)) {	×
390	const sourceEmailsEmail = sourceUser.emails.length > 0 && sourceUser.emails[0]	×
391	const targetEmailsEmail = targetUser.email.length > 0 && targetUser.emails[0]	×
392
393	if (sourceEmailsEmail === targetEmailsEmail) {	×
394	await Users.rawUpdateOne(	×
395	{_id: sourceUserId},
396	{$set: {
397	'emails.0': {address: newEmail, verified: sourceEmailsEmail ? sourceEmailsEmail.verified : false}	×
398	}}
399	);
400	}
401	}
402	}
403	} catch (err) {
404	// eslint-disable-next-line no-console
405	console.log("%c Error changing emails", "color: red")	×
406	// eslint-disable-next-line no-console
407	console.log(err)	×
408	}
409
410	// if the two accounts share a displayName, change the sourceUSer to " (Old)"
411	try {	×
412	if (!dryRun) {	×
413	if (sourceUser.displayName === targetUser.displayName) {	×
414	const newDisplayName = sourceUser.displayName + " (Old)"	×
415	await Users.rawUpdateOne({_id: sourceUserId}, {$set: { email: newDisplayName}}	×
416	);
417	}
418	}
419	} catch (err) {
420	// eslint-disable-next-line no-console
421	console.log("%c Error changing displayName", "color: red")	×
422	// eslint-disable-next-line no-console
423	console.log(err)	×
424	}
425
426	// Transfer email tokens
427	await transferCollection({sourceUserId, targetUserId, collectionName: "EmailTokens", dryRun})	×
428
429	if (!dryRun) {	×
430	// Mark old acccount as deleted
431	// eslint-disable-next-line no-console
432	console.log("Marking old account as deleted")	×
433	await updateMutator({	×
434	collection: Users,
435	documentId: sourceUserId,
436	set: {
437	deleted: true
438	},
439	// We remove the login tokins from the source account since it's now deleted
440	unset: {'services.resume':1},
441	validate: false
442	})
443	}
444	}
445
446
447	async function recomputeKarma(userId: string) {
448	const user = await Users.findOne({_id: userId})	×
449	if (!user) throw Error("Can't find user")	×
450	const selector: Record<string, any> = {	×
451	authorIds: user._id,
452	userId: {$ne: user._id},
453	cancelled: false,
454	collectionName: {$in: collectionsThatAffectKarma}
455	};
456	const rawAllTargetVotes = await Votes.find(selector).fetch()	×
457	const allTargetVotes = filterWhereFieldsNotNull(rawAllTargetVotes, "authorIds")	×
458	const karma = sumBy(allTargetVotes, vote => {	×
459	// a doc author cannot give karma to themselves or any other authors for that doc
460	return vote.authorIds.includes(vote.userId) ? 0 : vote.power	×
461	})
462	return karma	×
463	}
464
465	Vulcan.getTotalKarmaForUser = recomputeKarma	18✔

ForumMagnum / ForumMagnum / 8929626656

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