10895258791

Committed 17 Sep 2024 02:03AM UTC coverage: 31.878% (+0.006%) from 31.872%

Build # 10895258791

Build Type

Pull #9749

github

Committed by

Raemon

Commit Message

fix PR issues

Pull Request Pull Request #9749: Supplanting review bot

Run Details

5077 of 41312 branches covered (12.29%)

Branch coverage included in aggregate %.

23 of 41 new or added lines in 11 files covered. (56.1%)

2 existing lines in 1 file now uncovered.

29411 of 66877 relevant lines covered (43.98%)

185.05 hits per line

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

53.18

/packages/lesswrong/server/callbacks/votingCallbacks.ts

import moment from 'moment';
import Notifications from '../../lib/collections/notifications/collection';
import { Posts } from '../../lib/collections/posts/collection';
import Users from '../../lib/collections/users/collection';
import { isLWorAF, reviewMarketCreationMinimumKarmaSetting } from '../../lib/instanceSettings';
import type { VoteDocTuple } from '../../lib/voting/vote';
import { userSmallVotePower } from '../../lib/voting/voteTypes';
import { createNotification } from '../notificationCallbacksHelpers';
import { checkForStricterRateLimits } from '../rateLimitUtils';
import { batchUpdateScore } from '../updateScores';
import { triggerCommentAutomodIfNeeded } from "./sunshineCallbackUtils";
import { createMutator } from '../vulcan-lib/mutators';
import { Comments } from '../../lib/collections/comments';
import { createAdminContext } from '../vulcan-lib/query';
import Tags from '../../lib/collections/tags/collection';
import { isProduction } from '../../lib/executionEnvironment';
import { postGetPageUrl } from '../../lib/collections/posts/helpers';
import { createManifoldMarket } from '../../lib/collections/posts/annualReviewMarkets';
import { RECEIVED_SENIOR_DOWNVOTES_ALERT } from '../../lib/collections/moderatorActions/schema';
import { cancelAlignmentKarmaServerCallback, cancelAlignmentUserKarmaServer, updateAlignmentKarmaServerCallback, updateAlignmentUserServerCallback } from './alignment-forum/callbacks';
import { recomputeContributorScoresFor, voteUpdatePostDenormalizedTags } from '../tagging/tagCallbacks';
import { updateModerateOwnPersonal, updateTrustedStatus } from './userCallbacks';
import { increaseMaxBaseScore } from './postCallbacks';
import { captureException } from '@sentry/core';

export async function onVoteCancel(newDocument: DbVoteableType, vote: DbVote, collection: CollectionBase<VoteableCollectionName>, user: DbUser): Promise<void> {
  cancelAlignmentKarmaServerCallback({newDocument, vote});
  voteUpdatePostDenormalizedTags({newDocument});
  cancelVoteKarma({newDocument, vote}, collection, user);
  void cancelVoteCount({newDocument, vote});
  void cancelAlignmentUserKarmaServer({newDocument, vote});
  
  
  if (vote.collectionName === "Revisions") {
    const rev = (newDocument as DbRevision);
    if (rev.collectionName === "Tags") {
      await recomputeContributorScoresFor(newDocument as DbRevision, vote);
    }
  }
}
export async function onCastVoteSync(voteDocTuple: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser): Promise<VoteDocTuple> {
  return await updateAlignmentKarmaServerCallback(voteDocTuple);
}
export async function onCastVoteAsync(voteDocTuple: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext): Promise<void> {
  void updateAlignmentUserServerCallback(voteDocTuple);
  void updateTrustedStatus(voteDocTuple);
  void updateModerateOwnPersonal(voteDocTuple);
  void increaseMaxBaseScore(voteDocTuple);
  void voteUpdatePostDenormalizedTags(voteDocTuple);

  const { vote, newDocument } = voteDocTuple;
  if (vote.collectionName === "Revisions") {
    const rev = (newDocument as DbRevision);
    if (rev.collectionName === "Tags") {
      await recomputeContributorScoresFor(newDocument as DbRevision, vote);
    }
  }

  void updateKarma(voteDocTuple, collection, user, context);
  void incVoteCount(voteDocTuple);
  void checkAutomod(voteDocTuple, collection, user, context);
  await maybeCreateReviewMarket(voteDocTuple, collection, user, context);
  await maybeCreateModeratorAlertsAfterVote(voteDocTuple, collection, user, context);
}

export const collectionsThatAffectKarma = ["Posts", "Comments", "Revisions"]

function votesCanTriggerReview(content: DbPost | DbComment) {
  const sixMonthsAgo = moment().subtract(6, 'months');
  return moment(content.postedAt).isAfter(sixMonthsAgo);
}

/**
 * @summary Update the karma of the item's owner
 * @param {object} item - The item being operated on
 * @param {object} user - The user doing the operation
 * @param {object} collection - The collection the item belongs to
 * @param {string} operation - The operation being performed
 */
async function updateKarma({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext) {
  // Only update user karma if the operation isn't done by one of the item's current authors.
  // We don't want to let any of the authors give themselves or another author karma for this item.
  // We need to await it so that the subsequent check for whether any stricter rate limits apply can do a proper comparison between old and new karma
  if (vote.authorIds && !vote.authorIds.includes(vote.userId) && collectionsThatAffectKarma.includes(vote.collectionName)) {
  // if (!vote.authorIds.includes(vote.userId) && collectionsThatAffectKarma.includes(vote.collectionName)) {
    const users = await Users.find({_id: {$in: vote.authorIds}}).fetch();
    await Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {karma: vote.power}});
    
    if (newDocument.userId) {
      for (let user of users) {
        const oldKarma = user.karma;
        const newKarma = oldKarma + vote.power;
        void userKarmaChangedFrom(newDocument.userId, oldKarma, newKarma, context);
      }  
    }
  }

  
  if (!!newDocument.userId && isLWorAF && ['Posts', 'Comments'].includes(vote.collectionName) && votesCanTriggerReview(newDocument as DbPost | DbComment)) {
    void checkForStricterRateLimits(newDocument.userId, context);
  }
}

async function userKarmaChangedFrom(userId: string, oldKarma: number, newKarma: number, context: ResolverContext) {
  if (userSmallVotePower(oldKarma, 1) < userSmallVotePower(newKarma, 1)) {
    const yesterday = moment().subtract(1, 'days').toDate();
    const existingNotificationCount = await Notifications.find({userId, type: 'karmaPowersGained', createdAt: {$gt: yesterday}}).count();
    if (existingNotificationCount === 0) {
      await createNotification({
        userId,
        notificationType: 'karmaPowersGained',
        documentType: null,
        documentId: null,
        context
      })
    }
  }
};

function cancelVoteKarma({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser) {
  // Only update user karma if the operation isn't done by one of the item's authors at the time of the original vote.
  // We expect vote.authorIds here to be the same as the authorIds of the original vote.
  if (vote.authorIds && !vote.authorIds.includes(vote.userId) && collectionsThatAffectKarma.includes(vote.collectionName)) {
    void Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {karma: -vote.power}});
  }
}


async function incVoteCount ({newDocument, vote}: VoteDocTuple) {
  if (vote.voteType === "neutral") {
    return;
  }

  // Increment the count for the person casting the vote
  const casterField = `${vote.voteType}Count`

  if (newDocument.userId !== vote.userId) {
    void Users.rawUpdateOne({_id: vote.userId}, {$inc: {[casterField]: 1, voteCount: 1}});
  }

  // Increment the count for the person receiving the vote
  const receiverField = `${vote.voteType}ReceivedCount`

  if (newDocument.userId !== vote.userId) {
    // update all users in vote.authorIds
    void Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {[receiverField]: 1, voteReceivedCount: 1}});
  }
}

async function cancelVoteCount ({newDocument, vote}: VoteDocTuple) {
  if (vote.voteType === "neutral") {
    return;
  }

  const casterField = `${vote.voteType}Count`

  if (newDocument.userId !== vote.userId) {
    void Users.rawUpdateOne({_id: vote.userId}, {$inc: {[casterField]: -1, voteCount: -1}});
  }

  // Increment the count for the person receiving the vote
  const receiverField = `${vote.voteType}ReceivedCount`

  if (newDocument.userId !== vote.userId) {
    // update all users in vote.authorIds
    void Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {[receiverField]: -1, voteReceivedCount: -1}});
  }
}

async function checkAutomod ({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext) {
  if (vote.collectionName === 'Comments') {
    void triggerCommentAutomodIfNeeded(newDocument, vote);
  }
}


export async function updateScoreOnPostPublish(publishedPost: DbPost, context: ResolverContext) {
  // When a post is published (undrafted), update its score. (That is, recompute
  // the time-decaying score used for sorting, since the time that's computed
  // relative to has just changed).
  //
  // To do this, we mark it `inactive:false` and update the scores on the
  // whole collection. (This is already something being done frequently by a
  // cronjob.)
  if (publishedPost.inactive) {
    await Posts.rawUpdateOne({_id: publishedPost._id}, {$set: {inactive: false}});
  }
  
  await batchUpdateScore({collection: Posts});
}

// When a vote is cast, if its new karma is above review_market_threshold, create a Manifold
// on it making top 50 in the review, and create a comment linking to the market.

async function addTagToPost(postId: string, tagSlug: string, botUser: DbUser, context: ResolverContext) {
  const tag = await Tags.findOne({slug: tagSlug})
  const { addOrUpvoteTag } = require('../tagging/tagsGraphQL');
  if (!tag) {
    const name = tagSlug.split('-').map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(' ')
    const tagData = {
      name: name,
      slug: tagSlug,
      userId: botUser._id
    };   

    const {data: newTag} = await createMutator({
      collection: Tags,
      document: tagData,
      validate: false,
      currentUser: botUser,
    });
    if (!newTag) {
      //eslint-disable-next-line no-console
      console.log(`Failed to create tag with slug "${tagSlug}"`); 
      return;
    }
    await addOrUpvoteTag({tagId: newTag._id, postId: postId, currentUser: botUser, context});    
  }
  else {
    await addOrUpvoteTag({tagId: tag._id, postId: postId, currentUser: botUser, context});
  }
}

// AFAIU the flow, this has a race condition. If a post is voted on twice in quick succession, it will create two markets.
// This is probably fine, but it's worth noting. We can deal with it if it comes up.
async function maybeCreateReviewMarket({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext) {

  // Forum gate
  if (!isLWorAF) return;

  if (collection.collectionName !== "Posts") return;
  if (vote.power <= 0 || vote.cancelled) return; // In principle it would be fine to make a market here, but it should never be first created here
  if (newDocument.baseScore < reviewMarketCreationMinimumKarmaSetting.get()) return;
  const post = await Posts.findOne({_id: newDocument._id})
  if (!post) return;
  if (post.postedAt.getFullYear() < (new Date()).getFullYear() - 1) return; // only make markets for posts that haven't had a chance to be reviewed
  if (post.manifoldReviewMarketId) return;

  const annualReviewLink = 'https://www.lesswrong.com/tag/lesswrong-review'
  const postLink = postGetPageUrl(post, true)

  const year = post.postedAt.getFullYear()
  const initialProb = 14
  const question = `Will "${post.title.length < 50 ? post.title : (post.title.slice(0,45)+"...")}" make the top fifty posts in LessWrong's ${year} Annual Review?`
  const descriptionMarkdown = `As part of LessWrong's [Annual Review](${annualReviewLink}), the community nominates, writes reviews, and votes on the most valuable posts. Posts are reviewable once they have been up for at least 12 months, and the ${year} Review resolves in February ${year+2}.\n\n\nThis market will resolve to 100% if the post [${post.title}](${postLink}) is one of the top fifty posts of the ${year} Review, and 0% otherwise. The market was initialized to ${initialProb}%.`
  const closeTime = new Date(year + 2, 1, 1) // i.e. february 1st of the next next year (so if year is 2022, feb 1 of 2024)
  const visibility = isProduction ? "public" : "unlisted"

  const liteMarket = await createManifoldMarket(question, descriptionMarkdown, closeTime, visibility, initialProb)

  // Return if market creation fails
  if (!liteMarket) return;
  void Posts.rawUpdateOne(post._id, {$set: {manifoldReviewMarketId: liteMarket.id}})
}

async function maybeCreateModeratorAlertsAfterVote({ newDocument, vote }: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext) {
  if (!isLWorAF || vote.collectionName !== 'Comments' || !newDocument.userId) {
    return;
  }

  const adminContext = createAdminContext();

  const { userId } = newDocument;

  try {
    const [longtermDownvoteScore, previousAlert] = await Promise.all([
      context.repos.votes.getLongtermDownvoteScore(userId),
      context.ModeratorActions.findOne({ userId, type: RECEIVED_SENIOR_DOWNVOTES_ALERT }, { sort: { createdAt: -1 } })
    ]);
  
    // This seems to happen for new users or users who haven't been voted on at all by longterm senior users
    if (!longtermDownvoteScore) {
      return;
    }
  
    // If the user has already been flagged with this moderator action in the last month, no need to apply it again
    if (previousAlert && moment(previousAlert.createdAt).isAfter(moment().subtract(1, 'month'))) {
      return;
    }
  
    const {
      commentCount,
      longtermScore,
      longtermSeniorDownvoterCount
    } = longtermDownvoteScore;
  
    if (commentCount > 20 && longtermSeniorDownvoterCount >= 3 && longtermScore < 0) {
      void createMutator({
        collection: context.ModeratorActions,
        document: {
          type: RECEIVED_SENIOR_DOWNVOTES_ALERT,
          userId: userId,
          endedAt: new Date()
        },
        context: adminContext,
        currentUser: adminContext.currentUser,
      });
    }
  } catch (err) {
    captureException(err);
  }
}

1	import moment from 'moment';	461✔
2	import Notifications from '../../lib/collections/notifications/collection';	19✔
3	import { Posts } from '../../lib/collections/posts/collection';	19✔
4	import Users from '../../lib/collections/users/collection';	19✔
5	import { isLWorAF, reviewMarketCreationMinimumKarmaSetting } from '../../lib/instanceSettings';	19✔
6	import type { VoteDocTuple } from '../../lib/voting/vote';
7	import { userSmallVotePower } from '../../lib/voting/voteTypes';	19✔
8	import { createNotification } from '../notificationCallbacksHelpers';	19✔
9	import { checkForStricterRateLimits } from '../rateLimitUtils';	19✔
10	import { batchUpdateScore } from '../updateScores';	19✔
11	import { triggerCommentAutomodIfNeeded } from "./sunshineCallbackUtils";	19✔
12	import { createMutator } from '../vulcan-lib/mutators';	19✔
13	import { Comments } from '../../lib/collections/comments';
14	import { createAdminContext } from '../vulcan-lib/query';	19✔
15	import Tags from '../../lib/collections/tags/collection';	19✔
16	import { isProduction } from '../../lib/executionEnvironment';	19✔
17	import { postGetPageUrl } from '../../lib/collections/posts/helpers';	19✔
18	import { createManifoldMarket } from '../../lib/collections/posts/annualReviewMarkets';	19✔
19	import { RECEIVED_SENIOR_DOWNVOTES_ALERT } from '../../lib/collections/moderatorActions/schema';	19✔
20	import { cancelAlignmentKarmaServerCallback, cancelAlignmentUserKarmaServer, updateAlignmentKarmaServerCallback, updateAlignmentUserServerCallback } from './alignment-forum/callbacks';	19✔
21	import { recomputeContributorScoresFor, voteUpdatePostDenormalizedTags } from '../tagging/tagCallbacks';	19✔
22	import { updateModerateOwnPersonal, updateTrustedStatus } from './userCallbacks';	19✔
23	import { increaseMaxBaseScore } from './postCallbacks';	19✔
24	import { captureException } from '@sentry/core';	19✔
25
26	export async function onVoteCancel(newDocument: DbVoteableType, vote: DbVote, collection: CollectionBase<VoteableCollectionName>, user: DbUser): Promise<void> {
27	cancelAlignmentKarmaServerCallback({newDocument, vote});	7✔
28	voteUpdatePostDenormalizedTags({newDocument});	7✔
29	cancelVoteKarma({newDocument, vote}, collection, user);	7✔
30	void cancelVoteCount({newDocument, vote});	7✔
31	void cancelAlignmentUserKarmaServer({newDocument, vote});	7✔
32
33
34	if (vote.collectionName === "Revisions") {	7!
35	const rev = (newDocument as DbRevision);	×
36	if (rev.collectionName === "Tags") {	×
37	await recomputeContributorScoresFor(newDocument as DbRevision, vote);	×
38	}
39	}
40	}
41	export async function onCastVoteSync(voteDocTuple: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser): Promise<VoteDocTuple> {
42	return await updateAlignmentKarmaServerCallback(voteDocTuple);	147✔
43	}
44	export async function onCastVoteAsync(voteDocTuple: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext): Promise<void> {
45	void updateAlignmentUserServerCallback(voteDocTuple);	147✔
46	void updateTrustedStatus(voteDocTuple);	147✔
47	void updateModerateOwnPersonal(voteDocTuple);	147✔
48	void increaseMaxBaseScore(voteDocTuple);	147✔
49	void voteUpdatePostDenormalizedTags(voteDocTuple);	147✔
50
51	const { vote, newDocument } = voteDocTuple;	147✔
52	if (vote.collectionName === "Revisions") {	147✔
53	const rev = (newDocument as DbRevision);	2✔
54	if (rev.collectionName === "Tags") {	2!
55	await recomputeContributorScoresFor(newDocument as DbRevision, vote);	2✔
56	}
57	}
58
59	void updateKarma(voteDocTuple, collection, user, context);	147✔
60	void incVoteCount(voteDocTuple);	147✔
61	void checkAutomod(voteDocTuple, collection, user, context);	147✔
62	await maybeCreateReviewMarket(voteDocTuple, collection, user, context);	147✔
63	await maybeCreateModeratorAlertsAfterVote(voteDocTuple, collection, user, context);	147✔
64	}
65
66	export const collectionsThatAffectKarma = ["Posts", "Comments", "Revisions"]	19✔
67
68	function votesCanTriggerReview(content: DbPost \| DbComment) {
69	const sixMonthsAgo = moment().subtract(6, 'months');	×
70	return moment(content.postedAt).isAfter(sixMonthsAgo);	×
71	}
72
73	/**
74	* @summary Update the karma of the item's owner
75	* @param {object} item - The item being operated on
76	* @param {object} user - The user doing the operation
77	* @param {object} collection - The collection the item belongs to
78	* @param {string} operation - The operation being performed
79	*/
80	async function updateKarma({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext) {
81	// Only update user karma if the operation isn't done by one of the item's current authors.
82	// We don't want to let any of the authors give themselves or another author karma for this item.
83	// We need to await it so that the subsequent check for whether any stricter rate limits apply can do a proper comparison between old and new karma
84	if (vote.authorIds && !vote.authorIds.includes(vote.userId) && collectionsThatAffectKarma.includes(vote.collectionName)) {	147✔
85	// if (!vote.authorIds.includes(vote.userId) && collectionsThatAffectKarma.includes(vote.collectionName)) {
86	const users = await Users.find({_id: {$in: vote.authorIds}}).fetch();	19✔
87	await Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {karma: vote.power}});	19✔
88
89	if (newDocument.userId) {	19!
90	for (let user of users) {	19✔
91	const oldKarma = user.karma;	21✔
92	const newKarma = oldKarma + vote.power;	21✔
93	void userKarmaChangedFrom(newDocument.userId, oldKarma, newKarma, context);	21✔
94	}
95	}
96	}
97
98
99	if (!!newDocument.userId && isLWorAF && ['Posts', 'Comments'].includes(vote.collectionName) && votesCanTriggerReview(newDocument as DbPost \| DbComment)) {	147!
100	void checkForStricterRateLimits(newDocument.userId, context);	×
101	}
102	}
103
104	async function userKarmaChangedFrom(userId: string, oldKarma: number, newKarma: number, context: ResolverContext) {
105	if (userSmallVotePower(oldKarma, 1) < userSmallVotePower(newKarma, 1)) {	21!
106	const yesterday = moment().subtract(1, 'days').toDate();	×
107	const existingNotificationCount = await Notifications.find({userId, type: 'karmaPowersGained', createdAt: {$gt: yesterday}}).count();	×
108	if (existingNotificationCount === 0) {	×
109	await createNotification({	×
110	userId,
111	notificationType: 'karmaPowersGained',
112	documentType: null,
113	documentId: null,
114	context
115	})
116	}
117	}
118	};
119
120	function cancelVoteKarma({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser) {
121	// Only update user karma if the operation isn't done by one of the item's authors at the time of the original vote.
122	// We expect vote.authorIds here to be the same as the authorIds of the original vote.
123	if (vote.authorIds && !vote.authorIds.includes(vote.userId) && collectionsThatAffectKarma.includes(vote.collectionName)) {	7✔
124	void Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {karma: -vote.power}});	5✔
125	}
126	}
127
128
129	async function incVoteCount ({newDocument, vote}: VoteDocTuple) {
130	if (vote.voteType === "neutral") {	147✔
131	return;	6✔
132	}
133
134	// Increment the count for the person casting the vote
135	const casterField = `${vote.voteType}Count`	141✔
136
137	if (newDocument.userId !== vote.userId) {	141✔
138	void Users.rawUpdateOne({_id: vote.userId}, {$inc: {[casterField]: 1, voteCount: 1}});	13✔
139	}
140
141	// Increment the count for the person receiving the vote
142	const receiverField = `${vote.voteType}ReceivedCount`	141✔
143
144	if (newDocument.userId !== vote.userId) {	141✔
145	// update all users in vote.authorIds
146	void Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {[receiverField]: 1, voteReceivedCount: 1}});	13✔
147	}
148	}
149
150	async function cancelVoteCount ({newDocument, vote}: VoteDocTuple) {
151	if (vote.voteType === "neutral") {	7✔
152	return;	2✔
153	}
154
155	const casterField = `${vote.voteType}Count`	5✔
156
157	if (newDocument.userId !== vote.userId) {	5✔
158	void Users.rawUpdateOne({_id: vote.userId}, {$inc: {[casterField]: -1, voteCount: -1}});	3✔
159	}
160
161	// Increment the count for the person receiving the vote
162	const receiverField = `${vote.voteType}ReceivedCount`	5✔
163
164	if (newDocument.userId !== vote.userId) {	5✔
165	// update all users in vote.authorIds
166	void Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {[receiverField]: -1, voteReceivedCount: -1}});	3✔
167	}
168	}
169
170	async function checkAutomod ({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext) {
171	if (vote.collectionName === 'Comments') {	147✔
172	void triggerCommentAutomodIfNeeded(newDocument, vote);	29✔
173	}
174	}
175
176
177	export async function updateScoreOnPostPublish(publishedPost: DbPost, context: ResolverContext) {
178	// When a post is published (undrafted), update its score. (That is, recompute
179	// the time-decaying score used for sorting, since the time that's computed
180	// relative to has just changed).
181	//
182	// To do this, we mark it `inactive:false` and update the scores on the
183	// whole collection. (This is already something being done frequently by a
184	// cronjob.)
185	if (publishedPost.inactive) {	103!
186	await Posts.rawUpdateOne({_id: publishedPost._id}, {$set: {inactive: false}});	×
187	}
188
189	await batchUpdateScore({collection: Posts});	103✔
190	}
191
192	// When a vote is cast, if its new karma is above review_market_threshold, create a Manifold
193	// on it making top 50 in the review, and create a comment linking to the market.
194
195	async function addTagToPost(postId: string, tagSlug: string, botUser: DbUser, context: ResolverContext) {
UNCOV 196	const tag = await Tags.findOne({slug: tagSlug})	×
197	const { addOrUpvoteTag } = require('../tagging/tagsGraphQL');	×
198	if (!tag) {	×
199	const name = tagSlug.split('-').map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(' ')	×
200	const tagData = {	×
201	name: name,
202	slug: tagSlug,
203	userId: botUser._id
204	};
205
206	const {data: newTag} = await createMutator({	×
207	collection: Tags,
208	document: tagData,
209	validate: false,
210	currentUser: botUser,
211	});
212	if (!newTag) {	×
213	//eslint-disable-next-line no-console
214	console.log(`Failed to create tag with slug "${tagSlug}"`);	×
215	return;	×
216	}
217	await addOrUpvoteTag({tagId: newTag._id, postId: postId, currentUser: botUser, context});	×
218	}
219	else {
220	await addOrUpvoteTag({tagId: tag._id, postId: postId, currentUser: botUser, context});	×
221	}
222	}
223
224	// AFAIU the flow, this has a race condition. If a post is voted on twice in quick succession, it will create two markets.
225	// This is probably fine, but it's worth noting. We can deal with it if it comes up.
226	async function maybeCreateReviewMarket({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext) {
227
228	// Forum gate
229	if (!isLWorAF) return;	147!
230
UNCOV 231	if (collection.collectionName !== "Posts") return;	×
232	if (vote.power <= 0 \|\| vote.cancelled) return; // In principle it would be fine to make a market here, but it should never be first created here	×
233	if (newDocument.baseScore < reviewMarketCreationMinimumKarmaSetting.get()) return;	×
234	const post = await Posts.findOne({_id: newDocument._id})	×
235	if (!post) return;	×
236	if (post.postedAt.getFullYear() < (new Date()).getFullYear() - 1) return; // only make markets for posts that haven't had a chance to be reviewed	×
237	if (post.manifoldReviewMarketId) return;	×
238
239	const annualReviewLink = 'https://www.lesswrong.com/tag/lesswrong-review'	×
240	const postLink = postGetPageUrl(post, true)	×
241
242	const year = post.postedAt.getFullYear()	×
243	const initialProb = 14	×
244	const question = `Will "${post.title.length < 50 ? post.title : (post.title.slice(0,45)+"...")}" make the top fifty posts in LessWrong's ${year} Annual Review?`	×
245	const descriptionMarkdown = `As part of LessWrong's [Annual Review](${annualReviewLink}), the community nominates, writes reviews, and votes on the most valuable posts. Posts are reviewable once they have been up for at least 12 months, and the ${year} Review resolves in February ${year+2}.\n\n\nThis market will resolve to 100% if the post [${post.title}](${postLink}) is one of the top fifty posts of the ${year} Review, and 0% otherwise. The market was initialized to ${initialProb}%.`	×
246	const closeTime = new Date(year + 2, 1, 1) // i.e. february 1st of the next next year (so if year is 2022, feb 1 of 2024)	×
247	const visibility = isProduction ? "public" : "unlisted"	×
248
249	const liteMarket = await createManifoldMarket(question, descriptionMarkdown, closeTime, visibility, initialProb)	×
250
251	// Return if market creation fails
252	if (!liteMarket) return;	×
NEW 253	void Posts.rawUpdateOne(post._id, {$set: {manifoldReviewMarketId: liteMarket.id}})	×
254	}
255
256	async function maybeCreateModeratorAlertsAfterVote({ newDocument, vote }: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext) {
257	if (!isLWorAF \|\| vote.collectionName !== 'Comments' \|\| !newDocument.userId) {	147!
258	return;	147✔
259	}
260
261	const adminContext = createAdminContext();	×
262
263	const { userId } = newDocument;	×
264
265	try {	×
266	const [longtermDownvoteScore, previousAlert] = await Promise.all([	×
267	context.repos.votes.getLongtermDownvoteScore(userId),
268	context.ModeratorActions.findOne({ userId, type: RECEIVED_SENIOR_DOWNVOTES_ALERT }, { sort: { createdAt: -1 } })
269	]);
270
271	// This seems to happen for new users or users who haven't been voted on at all by longterm senior users
272	if (!longtermDownvoteScore) {	×
273	return;	×
274	}
275
276	// If the user has already been flagged with this moderator action in the last month, no need to apply it again
277	if (previousAlert && moment(previousAlert.createdAt).isAfter(moment().subtract(1, 'month'))) {	×
278	return;	×
279	}
280
281	const {
282	commentCount,
283	longtermScore,
284	longtermSeniorDownvoterCount
285	} = longtermDownvoteScore;	×
286
287	if (commentCount > 20 && longtermSeniorDownvoterCount >= 3 && longtermScore < 0) {	×
288	void createMutator({	×
289	collection: context.ModeratorActions,
290	document: {
291	type: RECEIVED_SENIOR_DOWNVOTES_ALERT,
292	userId: userId,
293	endedAt: new Date()
294	},
295	context: adminContext,
296	currentUser: adminContext.currentUser,
297	});
298	}
299	} catch (err) {
300	captureException(err);	×
301	}
302	}

ForumMagnum / ForumMagnum / 10895258791

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