9765867213

Committed 02 Jul 2024 06:05PM UTC coverage: 31.917% (-0.02%) from 31.934%

Build # 9765867213

Build Type

push

github

Committed by

b0b3rt

Commit Message

fix flipped conditional

Run Details

4887 of 40030 branches covered (12.21%)

Branch coverage included in aggregate %.

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

1 existing line in 1 file now uncovered.

28491 of 64546 relevant lines covered (44.14%)

180.75 hits per line

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

47.87

/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 { voteCallbacks, VoteDocTuple } from '../../lib/voting/vote';
import { userSmallVotePower } from '../../lib/voting/voteTypes';
import { postPublishedCallback } from '../notificationCallbacks';
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';
import { addOrUpvoteTag } from '../tagging/tagsGraphQL';
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 { captureException } from '@sentry/core';

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
 */
voteCallbacks.castVoteAsync.add(async function updateKarma({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context) {
  // 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
      })
    }
  }
};

voteCallbacks.cancelAsync.add(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}});
  }
});


voteCallbacks.castVoteAsync.add(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}});
  }
});

voteCallbacks.cancelAsync.add(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}});
  }
});

voteCallbacks.castVoteAsync.add(async function checkAutomod ({newDocument, vote}: VoteDocTuple, collection, user, context) {
  if (vote.collectionName === 'Comments') {
    void triggerCommentAutomodIfNeeded(newDocument, vote);
  }
});


postPublishedCallback.add(async (publishedPost: DbPost) => {
  // 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})
  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.
voteCallbacks.castVoteAsync.add(async ({newDocument, vote}: VoteDocTuple, collection, user, context) => {

  // 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
}

voteCallbacks.castVoteAsync.add(async ({ newDocument, vote }, collection, user, context) => {
  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';	54✔
2	import Notifications from '../../lib/collections/notifications/collection';	18✔
3	import { Posts } from '../../lib/collections/posts/collection';	18✔
4	import Users from '../../lib/collections/users/collection';	18✔
5	import { isLWorAF, reviewMarketCreationMinimumKarmaSetting, reviewUserBotSetting } from '../../lib/instanceSettings';	18✔
6	import { voteCallbacks, VoteDocTuple } from '../../lib/voting/vote';	18✔
7	import { userSmallVotePower } from '../../lib/voting/voteTypes';	18✔
8	import { postPublishedCallback } from '../notificationCallbacks';	18✔
9	import { createNotification } from '../notificationCallbacksHelpers';	18✔
10	import { checkForStricterRateLimits } from '../rateLimitUtils';	18✔
11	import { batchUpdateScore } from '../updateScores';	18✔
12	import { triggerCommentAutomodIfNeeded } from "./sunshineCallbackUtils";	18✔
13	import { createMutator } from '../vulcan-lib/mutators';	18✔
14	import { Comments } from '../../lib/collections/comments';	18✔
15	import { createAdminContext } from '../vulcan-lib';	18✔
16	import { addOrUpvoteTag } from '../tagging/tagsGraphQL';	18✔
17	import Tags from '../../lib/collections/tags/collection';	18✔
18	import { isProduction } from '../../lib/executionEnvironment';	18✔
19	import { postGetPageUrl } from '../../lib/collections/posts/helpers';	18✔
20	import { createManifoldMarket } from '../posts/annualReviewMarkets';	18✔
21	import { RECEIVED_SENIOR_DOWNVOTES_ALERT } from '../../lib/collections/moderatorActions/schema';	18✔
22	import { captureException } from '@sentry/core';	18✔
23
24	export const collectionsThatAffectKarma = ["Posts", "Comments", "Revisions"]	18✔
25
26	function votesCanTriggerReview(content: DbPost \| DbComment) {
27	const sixMonthsAgo = moment().subtract(6, 'months');	×
NEW 28	return moment(content.postedAt).isAfter(sixMonthsAgo);	×
29	}
30
31	/**
32	* @summary Update the karma of the item's owner
33	* @param {object} item - The item being operated on
34	* @param {object} user - The user doing the operation
35	* @param {object} collection - The collection the item belongs to
36	* @param {string} operation - The operation being performed
37	*/
38	voteCallbacks.castVoteAsync.add(async function updateKarma({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context) {	18✔
39	// Only update user karma if the operation isn't done by one of the item's current authors.
40	// We don't want to let any of the authors give themselves or another author karma for this item.
41	// 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
42	if (vote.authorIds && !vote.authorIds.includes(vote.userId) && collectionsThatAffectKarma.includes(vote.collectionName)) {	142✔
43	// if (!vote.authorIds.includes(vote.userId) && collectionsThatAffectKarma.includes(vote.collectionName)) {
44	const users = await Users.find({_id: {$in: vote.authorIds}}).fetch();	19✔
45	await Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {karma: vote.power}});	19✔
46
47	if (newDocument.userId) {	19!
48	for (let user of users) {	19✔
49	const oldKarma = user.karma;	21✔
50	const newKarma = oldKarma + vote.power;	21✔
51	void userKarmaChangedFrom(newDocument.userId, oldKarma, newKarma, context);	21✔
52	}
53	}
54	}
55
56
57	if (!!newDocument.userId && isLWorAF && ['Posts', 'Comments'].includes(vote.collectionName) && votesCanTriggerReview(newDocument as DbPost \| DbComment)) {	142!
58	void checkForStricterRateLimits(newDocument.userId, context);	×
59	}
60	});
61
62	async function userKarmaChangedFrom(userId: string, oldKarma: number, newKarma: number, context: ResolverContext) {
63	if (userSmallVotePower(oldKarma, 1) < userSmallVotePower(newKarma, 1)) {	21!
64	const yesterday = moment().subtract(1, 'days').toDate();	×
65	const existingNotificationCount = await Notifications.find({userId, type: 'karmaPowersGained', createdAt: {$gt: yesterday}}).count();	×
66	if (existingNotificationCount === 0) {	×
67	await createNotification({	×
68	userId,
69	notificationType: 'karmaPowersGained',
70	documentType: null,
71	documentId: null,
72	context
73	})
74	}
75	}
76	};
77
78	voteCallbacks.cancelAsync.add(function cancelVoteKarma({newDocument, vote}: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser) {	18✔
79	// Only update user karma if the operation isn't done by one of the item's authors at the time of the original vote.
80	// We expect vote.authorIds here to be the same as the authorIds of the original vote.
81	if (vote.authorIds && !vote.authorIds.includes(vote.userId) && collectionsThatAffectKarma.includes(vote.collectionName)) {	7✔
82	void Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {karma: -vote.power}});	5✔
83	}
84	});
85
86
87	voteCallbacks.castVoteAsync.add(async function incVoteCount ({newDocument, vote}: VoteDocTuple) {	18✔
88	if (vote.voteType === "neutral") {	142✔
89	return;	6✔
90	}
91
92	// Increment the count for the person casting the vote
93	const casterField = `${vote.voteType}Count`	136✔
94
95	if (newDocument.userId !== vote.userId) {	136✔
96	void Users.rawUpdateOne({_id: vote.userId}, {$inc: {[casterField]: 1, voteCount: 1}});	13✔
97	}
98
99	// Increment the count for the person receiving the vote
100	const receiverField = `${vote.voteType}ReceivedCount`	136✔
101
102	if (newDocument.userId !== vote.userId) {	136✔
103	// update all users in vote.authorIds
104	void Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {[receiverField]: 1, voteReceivedCount: 1}});	13✔
105	}
106	});
107
108	voteCallbacks.cancelAsync.add(async function cancelVoteCount ({newDocument, vote}: VoteDocTuple) {	18✔
109	if (vote.voteType === "neutral") {	7✔
110	return;	2✔
111	}
112
113	const casterField = `${vote.voteType}Count`	5✔
114
115	if (newDocument.userId !== vote.userId) {	5✔
116	void Users.rawUpdateOne({_id: vote.userId}, {$inc: {[casterField]: -1, voteCount: -1}});	3✔
117	}
118
119	// Increment the count for the person receiving the vote
120	const receiverField = `${vote.voteType}ReceivedCount`	5✔
121
122	if (newDocument.userId !== vote.userId) {	5✔
123	// update all users in vote.authorIds
124	void Users.rawUpdateMany({_id: {$in: vote.authorIds}}, {$inc: {[receiverField]: -1, voteReceivedCount: -1}});	3✔
125	}
126	});
127
128	voteCallbacks.castVoteAsync.add(async function checkAutomod ({newDocument, vote}: VoteDocTuple, collection, user, context) {	18✔
129	if (vote.collectionName === 'Comments') {	142✔
130	void triggerCommentAutomodIfNeeded(newDocument, vote);	29✔
131	}
132	});
133
134
135	postPublishedCallback.add(async (publishedPost: DbPost) => {	18✔
136	// When a post is published (undrafted), update its score. (That is, recompute
137	// the time-decaying score used for sorting, since the time that's computed
138	// relative to has just changed).
139	//
140	// To do this, we mark it `inactive:false` and update the scores on the
141	// whole collection. (This is already something being done frequently by a
142	// cronjob.)
143	if (publishedPost.inactive) {	98!
144	await Posts.rawUpdateOne({_id: publishedPost._id}, {$set: {inactive: false}});	×
145	}
146
147	await batchUpdateScore({collection: Posts});	98✔
148	});
149
150	// When a vote is cast, if its new karma is above review_market_threshold, create a Manifold
151	// on it making top 50 in the review, and create a comment linking to the market.
152
153	const reviewUserBot = reviewUserBotSetting.get()	18✔
154
155	async function addTagToPost(postId: string, tagSlug: string, botUser: DbUser, context: ResolverContext) {
156	const tag = await Tags.findOne({slug: tagSlug})	×
157	if (!tag) {	×
158	const name = tagSlug.split('-').map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(' ')	×
159	const tagData = {	×
160	name: name,
161	slug: tagSlug,
162	userId: botUser._id
163	};
164
165	const {data: newTag} = await createMutator({	×
166	collection: Tags,
167	document: tagData,
168	validate: false,
169	currentUser: botUser,
170	});
171	if (!newTag) {	×
172	//eslint-disable-next-line no-console
173	console.log(`Failed to create tag with slug "${tagSlug}"`);	×
174	return;	×
175	}
176	await addOrUpvoteTag({tagId: newTag._id, postId: postId, currentUser: botUser, context});	×
177	}
178	else {
179	await addOrUpvoteTag({tagId: tag._id, postId: postId, currentUser: botUser, context});	×
180	}
181	}
182
183	// AFAIU the flow, this has a race condition. If a post is voted on twice in quick succession, it will create two markets.
184	// This is probably fine, but it's worth noting. We can deal with it if it comes up.
185	voteCallbacks.castVoteAsync.add(async ({newDocument, vote}: VoteDocTuple, collection, user, context) => {	18✔
186
187	// Forum gate
188	if (!isLWorAF) return;	142!
189	if (!reviewUserBot) {	×
190	//eslint-disable-next-line no-console
191	console.error("Review bot user not configured");	×
192	return;	×
193	}
194
195	if (collection.collectionName !== "Posts") return;	×
196	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	×
197	if (newDocument.baseScore < reviewMarketCreationMinimumKarmaSetting.get()) return;	×
198	const post = await Posts.findOne({_id: newDocument._id})	×
199	if (!post) return;	×
200	if (post.postedAt.getFullYear() < (new Date()).getFullYear() - 1) return; // only make markets for posts that haven't had a chance to be reviewed	×
201	if (post.manifoldReviewMarketId) return;	×
202
203	const botUser = await context.Users.findOne({_id: reviewUserBot})	×
204	if (!botUser) {	×
205	//eslint-disable-next-line no-console
206	console.error("Bot user not found");	×
207	return	×
208	}
209
210	const annualReviewLink = 'https://www.lesswrong.com/tag/lesswrong-review'	×
211	const postLink = postGetPageUrl(post, true)	×
212
213	const year = post.postedAt.getFullYear()	×
214	const initialProb = 14	×
215	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?`	×
216	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}%.`	×
217	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)	×
218	const visibility = isProduction ? "public" : "unlisted"	×
219
220	const liteMarket = await createManifoldMarket(question, descriptionMarkdown, closeTime, visibility, initialProb)	×
221
222	// Return if market creation fails
223	if (!liteMarket) return;	×
224
225	const [comment] = await Promise.all([	×
226	makeMarketComment(post._id, year, liteMarket.url, botUser),
227	Posts.rawUpdateOne(post._id, {$set: {manifoldReviewMarketId: liteMarket.id}}),
228	])
229
230	await Posts.rawUpdateOne(post._id, {$set: {annualReviewMarketCommentId: comment._id}})	×
231	})
232
233	const makeMarketComment = async (postId: string, year: number, marketUrl: string, botUser: DbUser) => {	18✔
234
235	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>	×
236	`
237
238	const result = await createMutator({	×
239	collection: Comments,
240	document: {
241	postId: postId,
242	userId: botUser._id,
243	contents: {originalContents: {
244	type: "html",
245	data: commentString
246	}}
247	},
248	currentUser: botUser,
249	context: createAdminContext()
250	})
251
252
253	return result.data	×
254	}
255
256	voteCallbacks.castVoteAsync.add(async ({ newDocument, vote }, collection, user, context) => {	18✔
257	if (!isLWorAF \|\| vote.collectionName !== 'Comments' \|\| !newDocument.userId) {	142!
258	return;	142✔
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 / 9765867213

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