10691729161

Committed 03 Sep 2024 10:37PM UTC coverage: 31.859% (+0.02%) from 31.837%

Build # 10691729161

Build Type

Pull #9698

github

Committed by

web-flow

Commit Message

Merge e63f290db into a6ff63a86

Pull Request Pull Request #9698: Merge master into lw-deploy

Run Details

5070 of 41258 branches covered (12.29%)

Branch coverage included in aggregate %.

158 of 296 new or added lines in 39 files covered. (53.38%)

50 existing lines in 42 files now uncovered.

29365 of 66826 relevant lines covered (43.94%)

184.71 hits per line

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

50.42

/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, reviewUserBotSetting } 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 '../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.

const reviewUserBot = reviewUserBotSetting.get()

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 (!reviewUserBot) {
    //eslint-disable-next-line no-console
    console.error("Review bot user not configured"); 
    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 botUser = await context.Users.findOne({_id: reviewUserBot})
  if (!botUser) {
    //eslint-disable-next-line no-console
    console.error("Bot user not found"); 
    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;

  const [comment] = await Promise.all([
    makeMarketComment(post._id, year, liteMarket.url, botUser),
    Posts.rawUpdateOne(post._id, {$set: {manifoldReviewMarketId: liteMarket.id}}),
  ])

  await Posts.rawUpdateOne(post._id, {$set: {annualReviewMarketCommentId: comment._id}})
}

const makeMarketComment = async (postId: string, year: number, marketUrl: string, botUser: DbUser) => {

  const commentString = `<p>The <a href="https://www.lesswrong.com/bestoflesswrong">LessWrong Review</a> runs every year to select the posts that have most stood the test of time. This post is not yet eligible for review, but will be at the end of ${year+1}. The top fifty or so posts are featured prominently on the site throughout the year.</p><p>Hopefully, the review is better than karma at judging enduring value. If we have accurate prediction markets on the review results, maybe we can have better incentives on LessWrong today. <a href="${marketUrl}">Will this post make the top fifty?</a></p>
  `

  const result = await createMutator({
    collection: Comments,
    document: {
      postId: postId,
      userId: botUser._id,
      contents: {originalContents: {
        type: "html",
        data: commentString
      }}
    },
    currentUser: botUser,
    context: createAdminContext()
  })


  return result.data
}

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, reviewUserBotSetting } 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';	19✔
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 '../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!
NEW 35	const rev = (newDocument as DbRevision);	×
NEW 36	if (rev.collectionName === "Tags") {	×
NEW 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	const reviewUserBot = reviewUserBotSetting.get()	19✔
196
197	async function addTagToPost(postId: string, tagSlug: string, botUser: DbUser, context: ResolverContext) {
198	const tag = await Tags.findOne({slug: tagSlug})	×
NEW 199	const { addOrUpvoteTag } = require('../tagging/tagsGraphQL');	×
200	if (!tag) {	×
201	const name = tagSlug.split('-').map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(' ')	×
202	const tagData = {	×
203	name: name,
204	slug: tagSlug,
205	userId: botUser._id
206	};
207
208	const {data: newTag} = await createMutator({	×
209	collection: Tags,
210	document: tagData,
211	validate: false,
212	currentUser: botUser,
213	});
214	if (!newTag) {	×
215	//eslint-disable-next-line no-console
216	console.log(`Failed to create tag with slug "${tagSlug}"`);	×
217	return;	×
218	}
219	await addOrUpvoteTag({tagId: newTag._id, postId: postId, currentUser: botUser, context});	×
220	}
221	else {
222	await addOrUpvoteTag({tagId: tag._id, postId: postId, currentUser: botUser, context});	×
223	}
224	}
225
226	// AFAIU the flow, this has a race condition. If a post is voted on twice in quick succession, it will create two markets.
227	// This is probably fine, but it's worth noting. We can deal with it if it comes up.
228	async function maybeCreateReviewMarket({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext) {
229
230	// Forum gate
231	if (!isLWorAF) return;	147!
232	if (!reviewUserBot) {	×
233	//eslint-disable-next-line no-console
234	console.error("Review bot user not configured");	×
235	return;	×
236	}
237
238	if (collection.collectionName !== "Posts") return;	×
239	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	×
240	if (newDocument.baseScore < reviewMarketCreationMinimumKarmaSetting.get()) return;	×
241	const post = await Posts.findOne({_id: newDocument._id})	×
242	if (!post) return;	×
243	if (post.postedAt.getFullYear() < (new Date()).getFullYear() - 1) return; // only make markets for posts that haven't had a chance to be reviewed	×
244	if (post.manifoldReviewMarketId) return;	×
245
246	const botUser = await context.Users.findOne({_id: reviewUserBot})	×
247	if (!botUser) {	×
248	//eslint-disable-next-line no-console
249	console.error("Bot user not found");	×
250	return	×
251	}
252
253	const annualReviewLink = 'https://www.lesswrong.com/tag/lesswrong-review'	×
254	const postLink = postGetPageUrl(post, true)	×
255
256	const year = post.postedAt.getFullYear()	×
257	const initialProb = 14	×
258	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?`	×
259	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}%.`	×
260	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)	×
261	const visibility = isProduction ? "public" : "unlisted"	×
262
263	const liteMarket = await createManifoldMarket(question, descriptionMarkdown, closeTime, visibility, initialProb)	×
264
265	// Return if market creation fails
266	if (!liteMarket) return;	×
267
268	const [comment] = await Promise.all([	×
269	makeMarketComment(post._id, year, liteMarket.url, botUser),
270	Posts.rawUpdateOne(post._id, {$set: {manifoldReviewMarketId: liteMarket.id}}),
271	])
272
273	await Posts.rawUpdateOne(post._id, {$set: {annualReviewMarketCommentId: comment._id}})	×
274	}
275
276	const makeMarketComment = async (postId: string, year: number, marketUrl: string, botUser: DbUser) => {	19✔
277
278	const commentString = `<p>The <a href="https://www.lesswrong.com/bestoflesswrong">LessWrong Review</a> runs every year to select the posts that have most stood the test of time. This post is not yet eligible for review, but will be at the end of ${year+1}. The top fifty or so posts are featured prominently on the site throughout the year.</p><p>Hopefully, the review is better than karma at judging enduring value. If we have accurate prediction markets on the review results, maybe we can have better incentives on LessWrong today. <a href="${marketUrl}">Will this post make the top fifty?</a></p>	×
279	`
280
281	const result = await createMutator({	×
282	collection: Comments,
283	document: {
284	postId: postId,
285	userId: botUser._id,
286	contents: {originalContents: {
287	type: "html",
288	data: commentString
289	}}
290	},
291	currentUser: botUser,
292	context: createAdminContext()
293	})
294
295
296	return result.data	×
297	}
298
299	async function maybeCreateModeratorAlertsAfterVote({ newDocument, vote }: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext) {
300	if (!isLWorAF \|\| vote.collectionName !== 'Comments' \|\| !newDocument.userId) {	147!
301	return;	147✔
302	}
303
304	const adminContext = createAdminContext();	×
305
306	const { userId } = newDocument;	×
307
308	try {	×
309	const [longtermDownvoteScore, previousAlert] = await Promise.all([	×
310	context.repos.votes.getLongtermDownvoteScore(userId),
311	context.ModeratorActions.findOne({ userId, type: RECEIVED_SENIOR_DOWNVOTES_ALERT }, { sort: { createdAt: -1 } })
312	]);
313
314	// This seems to happen for new users or users who haven't been voted on at all by longterm senior users
315	if (!longtermDownvoteScore) {	×
316	return;	×
317	}
318
319	// If the user has already been flagged with this moderator action in the last month, no need to apply it again
320	if (previousAlert && moment(previousAlert.createdAt).isAfter(moment().subtract(1, 'month'))) {	×
321	return;	×
322	}
323
324	const {
325	commentCount,
326	longtermScore,
327	longtermSeniorDownvoterCount
328	} = longtermDownvoteScore;	×
329
330	if (commentCount > 20 && longtermSeniorDownvoterCount >= 3 && longtermScore < 0) {	×
331	void createMutator({	×
332	collection: context.ModeratorActions,
333	document: {
334	type: RECEIVED_SENIOR_DOWNVOTES_ALERT,
335	userId: userId,
336	endedAt: new Date()
337	},
338	context: adminContext,
339	currentUser: adminContext.currentUser,
340	});
341	}
342	} catch (err) {
343	captureException(err);	×
344	}
345	}

ForumMagnum / ForumMagnum / 10691729161

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