11525906268

Committed 25 Oct 2024 09:53PM UTC coverage: 31.472% (-0.001%) from 31.473%

Build # 11525906268

Build Type

Pull #9906

github

Committed by

rjmk

Commit Message

Tweaks to the Manifold Markets bot

Pull Request Pull Request #9906: Tweaks to the Manifold Markets bot

Run Details

5017 of 41807 branches covered (12.0%)

Branch coverage included in aggregate %.

1 of 2 new or added lines in 2 files covered. (50.0%)

1 existing line in 1 file now uncovered.

29435 of 67661 relevant lines covered (43.5%)

174.3 hits per line

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

52.04

/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 { revokeUserAFKarmaForCancelledVote, grantUserAFKarmaForVote } 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> {
  voteUpdatePostDenormalizedTags({newDocument});
  cancelVoteKarma({newDocument, vote}, collection, user);
  void cancelVoteCount({newDocument, vote});
  void revokeUserAFKarmaForCancelledVote({newDocument, vote});
  
  
  if (vote.collectionName === "Revisions") {
    const rev = (newDocument as DbRevision);
    if (rev.collectionName === "Tags") {
      await recomputeContributorScoresFor(newDocument as DbRevision, vote);
    }
  }
}
export async function onCastVoteAsync(voteDocTuple: VoteDocTuple, collection: CollectionBase<VoteableCollectionName>, user: DbUser, context: ResolverContext): Promise<void> {
  void grantUserAFKarmaForVote(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 || post.draft || post.deletedDraft) 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, post._id)

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

ForumMagnum / ForumMagnum / 11525906268

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