10709183381

Committed 04 Sep 2024 08:39PM UTC coverage: 31.908% (+0.03%) from 31.878%

Build # 10709183381

Build Type

Pull #9704

github

Committed by

ben-pace

Commit Message

teeny edits

Pull Request Pull Request #9704: Curation Page

Run Details

5027 of 41142 branches covered (12.22%)

Branch coverage included in aggregate %.

53 of 93 new or added lines in 14 files covered. (56.99%)

879 existing lines in 27 files now uncovered.

29385 of 66707 relevant lines covered (44.05%)

188.34 hits per line

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

36.92

/packages/lesswrong/lib/collections/posts/helpers.ts

import { PublicInstanceSetting, aboutPostIdSetting, isAF, isLWorAF, siteUrlSetting } from '../../instanceSettings';
import { getOutgoingUrl, getSiteUrl } from '../../vulcan-lib/utils';
import { mongoFindOne } from '../../mongoQueries';
import { userOwns, userCanDo } from '../../vulcan-users/permissions';
import { userGetDisplayName, userIsSharedOn } from '../users/helpers';
import { postStatuses, postStatusLabels } from './constants';
import { DatabasePublicSetting, cloudinaryCloudNameSetting, commentPermalinkStyleSetting } from '../../publicSettings';
import Localgroups from '../localgroups/collection';
import { max } from "underscore";
import { TupleSet, UnionOf } from '../../utils/typeGuardUtils';
import type { Request, Response } from 'express';
import pathToRegexp from "path-to-regexp";
import type { RouterLocation } from '../../vulcan-lib/routes';

export const postCategories = new TupleSet(['post', 'linkpost', 'question'] as const);
export type PostCategory = UnionOf<typeof postCategories>;
export const postDefaultCategory = 'post';
export const isPostCategory = (tab: string): tab is PostCategory => postCategories.has(tab)

//////////////////
// Link Helpers //
//////////////////

// Return a post's link if it has one, else return its post page URL
export const postGetLink = function (post: PostsBase|DbPost, isAbsolute=false, isRedirected=true): string {
  const foreignId = "fmCrosspost" in post && post.fmCrosspost?.isCrosspost && !post.fmCrosspost.hostedHere
    ? post.fmCrosspost.foreignPostId
    : undefined;
  if (post.url) {
    return isRedirected ? getOutgoingUrl(post.url, foreignId ?? undefined) : post.url;
  }
  return postGetPageUrl(post, isAbsolute);
};

// Whether a post's link should open in a new tab or not
export const postGetLinkTarget = function (post: PostsBase|DbPost): string {
  return !!post.url ? '_blank' : '';
};

///////////////////
// Other Helpers //
///////////////////

// Get a post author's name
export const postGetAuthorName = async function (post: DbPost): Promise<string> {
  var user = await mongoFindOne("Users", post.userId);
  if (user) {
    return userGetDisplayName(user);
  } else {
    return post.author ?? "[unknown author]";
  }
};

// Get default status for new posts.
export const postGetDefaultStatus = function (user: DbUser): number {
  return postStatuses.STATUS_APPROVED;
};

const findWhere = (array: any, criteria: any) => array.find((item: any) => Object.keys(criteria).every((key: any) => item[key] === criteria[key]));

// Get status name
export const postGetStatusName = function (post: DbPost): string {
  return findWhere(postStatusLabels, {value: post.status}).label;
};

// Check if a post is approved
export const postIsApproved = function (post: DbPost): boolean {
  return post.status === postStatuses.STATUS_APPROVED;
};

// Get URL for sharing on Twitter.
export const postGetTwitterShareUrl = (post: DbPost): string => {
  return `https://twitter.com/intent/tweet?text=${ encodeURIComponent(post.title) }%20${ encodeURIComponent(postGetLink(post, true)) }`;
};

// Get URL for sharing on Facebook.
export const postGetFacebookShareUrl = (post: DbPost): string => {
  return `https://www.facebook.com/sharer/sharer.php?u=${ encodeURIComponent(postGetLink(post, true)) }`;
};

// Get URL for sharing by Email.
export const postGetEmailShareUrl = (post: DbPost): string => {
  const subject = `Interesting link: ${post.title}`;
  const body = `I thought you might find this interesting:

${post.title}
${postGetLink(post, true, false)}

(found via ${siteUrlSetting.get()})
  `;
  return `mailto:?subject=${encodeURIComponent(subject)}&body=${encodeURIComponent(body)}`;
};

const getSocialImagePreviewPrefix = () =>
  `https://res.cloudinary.com/${cloudinaryCloudNameSetting.get()}/image/upload/c_fill,ar_1.91,g_auto/`;

// Select the social preview image for the post.
// For events, we use their event image if that is set.
// For other posts, we use the manually-set cloudinary image if available,
// or the auto-set from the post contents. If neither of those are available,
// it will return null.
export const getSocialPreviewImage = (post: DbPost): string => {
  // Note: in case of bugs due to failed migration of socialPreviewImageId -> socialPreview.imageId,
  // edit this to support the old field "socialPreviewImageId", which still has the old data
  const manualId = (post.isEvent && post.eventImageId) ? post.eventImageId : post.socialPreview?.imageId
  if (manualId) {
    return getSocialImagePreviewPrefix() + manualId;
  }
  const autoUrl = post.socialPreviewImageAutoUrl
  return autoUrl || ''
}

export const getSocialPreviewSql = (tablePrefix: string) => `JSON_BUILD_OBJECT(
  'imageUrl',
  CASE
    WHEN ${tablePrefix}."isEvent" AND ${tablePrefix}."eventImageId" IS NOT NULL
      THEN '${getSocialImagePreviewPrefix()}' || ${tablePrefix}."eventImageId"
    WHEN ${tablePrefix}."socialPreview"->>'imageId' IS NOT NULL
      THEN '${getSocialImagePreviewPrefix()}' || (${tablePrefix}."socialPreview"->>'imageId')
    ELSE COALESCE(${tablePrefix}."socialPreviewImageAutoUrl", '')
  END
)`;

// The set of fields required for calling postGetPageUrl. Could be supplied by
// either a fragment or a DbPost.
export interface PostsMinimumForGetPageUrl {
  _id: string
  slug: string
  isEvent?: boolean
  groupId?: string | undefined | null
}

// Get URL of a post page.
export const postGetPageUrl = function(post: PostsMinimumForGetPageUrl, isAbsolute=false, sequenceId: string|null=null): string {
  const prefix = isAbsolute ? getSiteUrl().slice(0,-1) : '';

  // LESSWRONG – included event and group post urls
  if (sequenceId) {
    return `${prefix}/s/${sequenceId}/p/${post._id}`;
  } else if (post.isEvent) {
    return `${prefix}/events/${post._id}/${post.slug}`;
  } else if (post.groupId) {
    return `${prefix}/g/${post.groupId}/p/${post._id}/`;
  }
  return `${prefix}/posts/${post._id}/${post.slug}`;
};

export const postGetCommentsUrl = (
  post: PostsMinimumForGetPageUrl,
  isAbsolute = false,
  sequenceId: string | null = null,
): string => {
  return postGetPageUrl(post, isAbsolute, sequenceId) + "#comments";
}

export const getPostCollaborateUrl = function (postId: string, isAbsolute=false, linkSharingKey?: string): string {
  const prefix = isAbsolute ? getSiteUrl().slice(0,-1) : '';
  if (linkSharingKey) {
    return `${prefix}/collaborateOnPost?postId=${postId}&key=${linkSharingKey}`;
  } else {
    return `${prefix}/collaborateOnPost?postId=${postId}`;
  }
}

export const postGetEditUrl = (postId: string, isAbsolute = false, linkSharingKey?: string, version?: string): string => {
  const prefix = isAbsolute ? getSiteUrl().slice(0, -1) : '';
  let url = `${prefix}/editPost?postId=${postId}`;
  if (linkSharingKey) url += `&key=${linkSharingKey}`;
  if (version) url += `&version=${version}`;
  return url;
}

export type PostWithCommentCounts = { commentCount: number; afCommentCount: number }
/**
 * Get the total (cached) number of comments, including replies and answers
 */
export const postGetCommentCount = (post: PostWithCommentCounts): number => {
  if (isAF) {
    return post.afCommentCount || 0;
  } else {
    return post.commentCount || 0;
  }
};

/**
 * Can pass in a manual comment count, or retrieve the post's cached comment count
 */
export const postGetCommentCountStr = (post?: PostWithCommentCounts|null, commentCount?: number|undefined): string => {
  const count = commentCount !== undefined ? commentCount : post ? postGetCommentCount(post) : 0;
  if (!count) {
    return "No comments";
  } else if (count === 1) {
    return "1 comment";
  } else {
    return count + " comments";
  }
}

export const postGetAnswerCountStr = (count: number): string => {
  if (!count) {
    return "No answers";
  } else if (count === 1) {
    return "1 answer";
  } else {
    return count + " answers";
  }
}

export const getResponseCounts = ({ post, answers }: { post: PostWithCommentCounts; answers: CommentsList[] }) => {
  // answers may include some which are deleted:true, deletedPublic:true (in which
  // case various fields are unpopulated and a deleted-item placeholder is shown
  // in the UI). These deleted answers are *not* included in post.commentCount.
  const nonDeletedAnswers = answers.filter((answer) => !answer.deleted);

  const answerAndDescendentsCount =
    answers.reduce((prev: number, curr: CommentsList) => prev + curr.descendentCount, 0) + answers.length;

  return {
    answerCount: nonDeletedAnswers.length,
    commentCount: postGetCommentCount(post) - answerAndDescendentsCount,
  };
};

export const postGetLastCommentedAt = (post: PostsBase|DbPost): Date | null => {
  if (isAF) {
    return post.afLastCommentedAt;
  } else {
    return post.lastCommentedAt;
  }
}

export const postGetLastCommentPromotedAt = (post: PostsBase|DbPost): Date|null => {
  if (isAF) return null
  // TODO: add an afLastCommentPromotedAt
  return post.lastCommentPromotedAt;
}

/**
 * Whether or not the given user is an organizer for the post's group
 * @param user
 * @param post
 * @returns {Promise} Promise object resolves to true if the post has a group and the user is an organizer for that group
 */
export const userIsPostGroupOrganizer = async (user: UsersMinimumInfo|DbUser|null, post: PostsBase|DbPost, context: ResolverContext|null): Promise<boolean> => {
  const groupId = ('group' in post) ? post.group?._id : post.groupId;
  if (!user || !groupId)
    return false
    
  const group = context
    ? await context.loaders.Localgroups.load(groupId)
    : await Localgroups.findOne({_id: groupId});
  return !!group && group.organizerIds.some(id => id === user._id);
}

/**
 * Whether the user can make updates to the post document (including both the main post body and most other post fields)
 */
export const canUserEditPostMetadata = (currentUser: UsersCurrent|DbUser|null, post: PostsBase|DbPost): boolean => {
  if (!currentUser) return false;

  const organizerIds = (post as PostsBase)?.group?.organizerIds;
  const isPostGroupOrganizer = organizerIds ? organizerIds.some(id => id === currentUser?._id) : false;
  if (isPostGroupOrganizer) return true

  if (userOwns(currentUser, post)) return true
  if (userCanDo(currentUser, 'posts.edit.all')) return true
  // Shared as a coauthor? Always give access
  if (post.coauthorStatuses && post.coauthorStatuses.findIndex(({ userId }) => userId === currentUser._id) >= 0) return true

  if (userIsSharedOn(currentUser, post) && post.sharingSettings?.anyoneWithLinkCan === "edit") return true 

  if (post.shareWithUsers?.includes(currentUser._id) && post.sharingSettings?.explicitlySharedUsersCan === "edit") return true 

  return false
}

export const postCanDelete = (currentUser: UsersCurrent|null, post: PostsBase): boolean => {
  if (userCanDo(currentUser, "posts.remove.all")) {
    return true
  }
  const organizerIds = post.group?.organizerIds;
  const isPostGroupOrganizer = organizerIds ? organizerIds.some(id => id === currentUser?._id) : false;
  return (userOwns(currentUser, post) || isPostGroupOrganizer) && post.draft
}

export const postGetKarma = (post: PostsBase|DbPost): number => {
  const baseScore = isAF ? post.afBaseScore : post.baseScore
  return baseScore || 0
}

// User can add/edit the hideCommentKarma setting if:
//  1) The user is logged in and has the requisite setting enabled
//  And
//  2) The post does not exist yet
//  Or if the post does exist
//  3) The post doesn't have any comments yet
export const postCanEditHideCommentKarma = (user: UsersCurrent|DbUser|null, post?: PostsBase|DbPost|null): boolean => {
  return !!(user?.showHideKarmaOption && (!post || !postGetCommentCount(post)))
}

export type CoauthoredPost = Partial<Pick<DbPost, "hasCoauthorPermission" | "coauthorStatuses">>

export const postCoauthorIsPending = (post: CoauthoredPost, coauthorUserId: string) => {
  if (post.hasCoauthorPermission) {
    return false;
  }
  const status = post.coauthorStatuses?.find(({ userId }) => coauthorUserId === userId);
  return status && !status.confirmed;
}

export const getConfirmedCoauthorIds = (post: CoauthoredPost): string[] => {
  let { coauthorStatuses, hasCoauthorPermission = true } = post;
  if (!coauthorStatuses) return []

  if (!hasCoauthorPermission) {
    coauthorStatuses = coauthorStatuses.filter(({ confirmed }) => confirmed);
  }
  return coauthorStatuses.map(({ userId }) => userId);
}

export const userIsPostCoauthor = (user: UsersMinimumInfo|DbUser|null, post: CoauthoredPost): boolean => {
  if (!user) {
    return false;
  }
  const userIds = getConfirmedCoauthorIds(post);
  return userIds.indexOf(user._id) >= 0;
}

export const isNotHostedHere = (post: PostsPage|DbPost) => {
  return post?.fmCrosspost?.isCrosspost && !post?.fmCrosspost?.hostedHere
}

const mostRelevantTag = (
  tags: TagPreviewFragment[],
  tagRelevance: Record<string, number>,
): TagPreviewFragment | null => max(tags, ({_id}) => tagRelevance[_id] ?? 0);

export const postGetPrimaryTag = (post: PostsListWithVotes, includeNonCore = false) => {
  const {tags, tagRelevance} = post;
  const core = tags.filter(({core}) => core);
  const potentialTags = core.length < 1 && includeNonCore ? tags : core;
  const result = mostRelevantTag(potentialTags, tagRelevance);
  return typeof result === "object" ? result : undefined;
}

const allowTypeIIIPlayerSetting = new PublicInstanceSetting<boolean>('allowTypeIIIPlayer', false, "optional")
const type3DateCutoffSetting = new DatabasePublicSetting<string>('type3.cutoffDate', '2023-05-01')
const type3ExplicitlyAllowedPostIdsSetting = new DatabasePublicSetting<string[]>('type3.explicitlyAllowedPostIds', [])
/** type3KarmaCutoffSetting is here to allow including high karma posts from before type3DateCutoffSetting */
const type3KarmaCutoffSetting = new DatabasePublicSetting<number>('type3.karmaCutoff', Infinity)

/**
 * Whether the post is allowed AI generated audio
 */
export const isPostAllowedType3Audio = (post: PostsBase|DbPost): boolean => {
  if (!allowTypeIIIPlayerSetting.get()) return false

  try {
    const TYPE_III_DATE_CUTOFF = new Date(type3DateCutoffSetting.get())
    const TYPE_III_ALLOWED_POST_IDS = type3ExplicitlyAllowedPostIdsSetting.get()

    return (
      (new Date(post.postedAt) >= TYPE_III_DATE_CUTOFF ||
        TYPE_III_ALLOWED_POST_IDS.includes(post._id) ||
        post.baseScore > type3KarmaCutoffSetting.get() ||
        post.forceAllowType3Audio) &&
      !post.draft &&
      !post.authorIsUnreviewed &&
      !post.rejected &&
      !post.podcastEpisodeId &&
      !post.isEvent &&
      !post.question &&
      !post.debate &&
      !post.shortform &&
      post.status === postStatuses.STATUS_APPROVED
    );
  } catch (e) {
    // eslint-disable-next-line no-console
    console.error(e)
    return false
  }
}

/**
 * Given a url like https://docs.google.com/document/d/1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA/edit#heading=h.82kaw9idgbpe
 * return just the id part (1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA in this case)
 */
export const extractGoogleDocId = (urlOrId: string): string | null => {
  const docIdMatch = urlOrId.match(/.*docs\.google\.com.*\/d\/(.+?)(\/|$)/);
  return docIdMatch ? docIdMatch[1] : null;
};

/**
 * Given a Google doc id like 1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA, return
 * the full url (as if you were able to edit it). In this case it would be
 * https://docs.google.com/document/d/1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA/edit
 */
export const googleDocIdToUrl = (docId: string): string => {
  return `https://docs.google.com/document/d/${docId}/edit`;
};

export const postRouteWillDefinitelyReturn200 = async (req: Request, res: Response, parsedRoute: RouterLocation, context: ResolverContext) => {
  const matchPostPath = pathToRegexp('/posts/:_id/:slug?');
  const [_, postId] = matchPostPath.exec(req.path) ?? [];

  if (postId) {
    if (req.query.commentId && commentPermalinkStyleSetting.get() === 'in-context') {
      // Will redirect from ?commentId=... to #...
      return false;
    }

    return await context.repos.posts.postRouteWillDefinitelyReturn200(postId);
  }
  return false;
}

export const isRecombeeRecommendablePost = (post: DbPost | PostsBase): boolean => {
  // We explicitly don't check `isFuture` here, because the cron job that "publishes" those posts does a raw update
  // So it won't trigger any of the callbacks, and if we exclude those posts they'll never get recommended
  // `Posts.checkAccess` already filters out posts with `isFuture` unless you're a mod or otherwise own the post
  // So we're not really in any danger of showing those posts to regular users
  // TODO: figure out how to handle this more gracefully
  return !(
    post.shortform
    || post.unlisted
    || post.rejected
    || post.isEvent
    || !!post.groupId
    || post.disableRecommendation
    || post.status !== 2
    || post._id === aboutPostIdSetting.get()
  );
};

1	import { PublicInstanceSetting, aboutPostIdSetting, isAF, isLWorAF, siteUrlSetting } from '../../instanceSettings';	895✔
2	import { getOutgoingUrl, getSiteUrl } from '../../vulcan-lib/utils';	26✔
3	import { mongoFindOne } from '../../mongoQueries';	26✔
4	import { userOwns, userCanDo } from '../../vulcan-users/permissions';	26✔
5	import { userGetDisplayName, userIsSharedOn } from '../users/helpers';	26✔
6	import { postStatuses, postStatusLabels } from './constants';	26✔
7	import { DatabasePublicSetting, cloudinaryCloudNameSetting, commentPermalinkStyleSetting } from '../../publicSettings';	26✔
8	import Localgroups from '../localgroups/collection';	26✔
9	import { max } from "underscore";	26✔
10	import { TupleSet, UnionOf } from '../../utils/typeGuardUtils';	26✔
11	import type { Request, Response } from 'express';
12	import pathToRegexp from "path-to-regexp";	26✔
13	import type { RouterLocation } from '../../vulcan-lib/routes';
14
15	export const postCategories = new TupleSet(['post', 'linkpost', 'question'] as const);	26✔
16	export type PostCategory = UnionOf<typeof postCategories>;
17	export const postDefaultCategory = 'post';	26✔
18	export const isPostCategory = (tab: string): tab is PostCategory => postCategories.has(tab)	26✔
19
20	//////////////////
21	// Link Helpers //
22	//////////////////
23
24	// Return a post's link if it has one, else return its post page URL
25	export const postGetLink = function (post: PostsBase\|DbPost, isAbsolute=false, isRedirected=true): string {	26!
26	const foreignId = "fmCrosspost" in post && post.fmCrosspost?.isCrosspost && !post.fmCrosspost.hostedHere	×
27	? post.fmCrosspost.foreignPostId	×
28	: undefined;
29	if (post.url) {	×
30	return isRedirected ? getOutgoingUrl(post.url, foreignId ?? undefined) : post.url;	×
31	}
32	return postGetPageUrl(post, isAbsolute);	×
33	};
34
35	// Whether a post's link should open in a new tab or not
36	export const postGetLinkTarget = function (post: PostsBase\|DbPost): string {	26✔
37	return !!post.url ? '_blank' : '';	×
38	};
39
40	///////////////////
41	// Other Helpers //
42	///////////////////
43
44	// Get a post author's name
45	export const postGetAuthorName = async function (post: DbPost): Promise<string> {	26✔
46	var user = await mongoFindOne("Users", post.userId);	9✔
47	if (user) {	9!
48	return userGetDisplayName(user);	9✔
49	} else {
50	return post.author ?? "[unknown author]";	×
51	}
52	};
53
54	// Get default status for new posts.
55	export const postGetDefaultStatus = function (user: DbUser): number {	26✔
56	return postStatuses.STATUS_APPROVED;	183✔
57	};
58
59	const findWhere = (array: any, criteria: any) => array.find((item: any) => Object.keys(criteria).every((key: any) => item[key] === criteria[key]));	26✔
60
61	// Get status name
62	export const postGetStatusName = function (post: DbPost): string {	26✔
63	return findWhere(postStatusLabels, {value: post.status}).label;	×
64	};
65
66	// Check if a post is approved
67	export const postIsApproved = function (post: DbPost): boolean {	26✔
68	return post.status === postStatuses.STATUS_APPROVED;	45✔
69	};
70
71	// Get URL for sharing on Twitter.
72	export const postGetTwitterShareUrl = (post: DbPost): string => {	26✔
73	return `https://twitter.com/intent/tweet?text=${ encodeURIComponent(post.title) }%20${ encodeURIComponent(postGetLink(post, true)) }`;	×
74	};
75
76	// Get URL for sharing on Facebook.
77	export const postGetFacebookShareUrl = (post: DbPost): string => {	26✔
78	return `https://www.facebook.com/sharer/sharer.php?u=${ encodeURIComponent(postGetLink(post, true)) }`;	×
79	};
80
81	// Get URL for sharing by Email.
82	export const postGetEmailShareUrl = (post: DbPost): string => {	26✔
83	const subject = `Interesting link: ${post.title}`;	×
84	const body = `I thought you might find this interesting:	×
85
86	${post.title}
87	${postGetLink(post, true, false)}
88
89	(found via ${siteUrlSetting.get()})
90	`;
91	return `mailto:?subject=${encodeURIComponent(subject)}&body=${encodeURIComponent(body)}`;	×
92	};
93
94	const getSocialImagePreviewPrefix = () =>	26✔
95	`https://res.cloudinary.com/${cloudinaryCloudNameSetting.get()}/image/upload/c_fill,ar_1.91,g_auto/`;	×
96
97	// Select the social preview image for the post.
98	// For events, we use their event image if that is set.
99	// For other posts, we use the manually-set cloudinary image if available,
100	// or the auto-set from the post contents. If neither of those are available,
101	// it will return null.
102	export const getSocialPreviewImage = (post: DbPost): string => {	26✔
103	// Note: in case of bugs due to failed migration of socialPreviewImageId -> socialPreview.imageId,
104	// edit this to support the old field "socialPreviewImageId", which still has the old data
105	const manualId = (post.isEvent && post.eventImageId) ? post.eventImageId : post.socialPreview?.imageId	2!
106	if (manualId) {	2!
107	return getSocialImagePreviewPrefix() + manualId;	×
108	}
109	const autoUrl = post.socialPreviewImageAutoUrl	2✔
110	return autoUrl \|\| ''	2✔
111	}
112
113	export const getSocialPreviewSql = (tablePrefix: string) => `JSON_BUILD_OBJECT(	26✔
114	'imageUrl',
115	CASE
116	WHEN ${tablePrefix}."isEvent" AND ${tablePrefix}."eventImageId" IS NOT NULL
117	THEN '${getSocialImagePreviewPrefix()}' \|\| ${tablePrefix}."eventImageId"
118	WHEN ${tablePrefix}."socialPreview"->>'imageId' IS NOT NULL
119	THEN '${getSocialImagePreviewPrefix()}' \|\| (${tablePrefix}."socialPreview"->>'imageId')
120	ELSE COALESCE(${tablePrefix}."socialPreviewImageAutoUrl", '')
121	END
122	)`;
123
124	// The set of fields required for calling postGetPageUrl. Could be supplied by
125	// either a fragment or a DbPost.
126	export interface PostsMinimumForGetPageUrl {
127	_id: string
128	slug: string
129	isEvent?: boolean
130	groupId?: string \| undefined \| null
131	}
132
133	// Get URL of a post page.
134	export const postGetPageUrl = function(post: PostsMinimumForGetPageUrl, isAbsolute=false, sequenceId: string\|null=null): string {	26!
135	const prefix = isAbsolute ? getSiteUrl().slice(0,-1) : '';	13!
136
137	// LESSWRONG – included event and group post urls
138	if (sequenceId) {	13!
139	return `${prefix}/s/${sequenceId}/p/${post._id}`;	×
140	} else if (post.isEvent) {	13!
141	return `${prefix}/events/${post._id}/${post.slug}`;	×
142	} else if (post.groupId) {	13!
143	return `${prefix}/g/${post.groupId}/p/${post._id}/`;	×
144	}
145	return `${prefix}/posts/${post._id}/${post.slug}`;	13✔
146	};
147
148	export const postGetCommentsUrl = (	26✔
149	post: PostsMinimumForGetPageUrl,
150	isAbsolute = false,	×
151	sequenceId: string \| null = null,	×
152	): string => {
153	return postGetPageUrl(post, isAbsolute, sequenceId) + "#comments";	×
154	}
155
156	export const getPostCollaborateUrl = function (postId: string, isAbsolute=false, linkSharingKey?: string): string {	26!
157	const prefix = isAbsolute ? getSiteUrl().slice(0,-1) : '';	×
158	if (linkSharingKey) {	×
159	return `${prefix}/collaborateOnPost?postId=${postId}&key=${linkSharingKey}`;	×
160	} else {
161	return `${prefix}/collaborateOnPost?postId=${postId}`;	×
162	}
163	}
164
165	export const postGetEditUrl = (postId: string, isAbsolute = false, linkSharingKey?: string, version?: string): string => {	26!
166	const prefix = isAbsolute ? getSiteUrl().slice(0, -1) : '';	3!
167	let url = `${prefix}/editPost?postId=${postId}`;	3✔
168	if (linkSharingKey) url += `&key=${linkSharingKey}`;	3!
169	if (version) url += `&version=${version}`;	3!
170	return url;	3✔
171	}
172
173	export type PostWithCommentCounts = { commentCount: number; afCommentCount: number }
174	/**
175	* Get the total (cached) number of comments, including replies and answers
176	*/
177	export const postGetCommentCount = (post: PostWithCommentCounts): number => {	26✔
178	if (isAF) {	×
179	return post.afCommentCount \|\| 0;	×
180	} else {
181	return post.commentCount \|\| 0;	×
182	}
183	};
184
185	/**
186	* Can pass in a manual comment count, or retrieve the post's cached comment count
187	*/
188	export const postGetCommentCountStr = (post?: PostWithCommentCounts\|null, commentCount?: number\|undefined): string => {	26✔
189	const count = commentCount !== undefined ? commentCount : post ? postGetCommentCount(post) : 0;	×
190	if (!count) {	×
191	return "No comments";	×
192	} else if (count === 1) {	×
193	return "1 comment";	×
194	} else {
195	return count + " comments";	×
196	}
197	}
198
199	export const postGetAnswerCountStr = (count: number): string => {	26✔
200	if (!count) {	×
201	return "No answers";	×
202	} else if (count === 1) {	×
203	return "1 answer";	×
204	} else {
205	return count + " answers";	×
206	}
207	}
208
209	export const getResponseCounts = ({ post, answers }: { post: PostWithCommentCounts; answers: CommentsList[] }) => {	26✔
210	// answers may include some which are deleted:true, deletedPublic:true (in which
211	// case various fields are unpopulated and a deleted-item placeholder is shown
212	// in the UI). These deleted answers are not included in post.commentCount.
213	const nonDeletedAnswers = answers.filter((answer) => !answer.deleted);	×
214
215	const answerAndDescendentsCount =
216	answers.reduce((prev: number, curr: CommentsList) => prev + curr.descendentCount, 0) + answers.length;	×
217
218	return {	×
219	answerCount: nonDeletedAnswers.length,
220	commentCount: postGetCommentCount(post) - answerAndDescendentsCount,
221	};
222	};
223
224	export const postGetLastCommentedAt = (post: PostsBase\|DbPost): Date \| null => {	26✔
225	if (isAF) {	×
226	return post.afLastCommentedAt;	×
227	} else {
228	return post.lastCommentedAt;	×
229	}
230	}
231
232	export const postGetLastCommentPromotedAt = (post: PostsBase\|DbPost): Date\|null => {	26✔
233	if (isAF) return null	×
234	// TODO: add an afLastCommentPromotedAt
235	return post.lastCommentPromotedAt;	×
236	}
237
238	/**
239	* Whether or not the given user is an organizer for the post's group
240	* @param user
241	* @param post
242	* @returns {Promise} Promise object resolves to true if the post has a group and the user is an organizer for that group
243	*/
244	export const userIsPostGroupOrganizer = async (user: UsersMinimumInfo\|DbUser\|null, post: PostsBase\|DbPost, context: ResolverContext\|null): Promise<boolean> => {	26✔
245	const groupId = ('group' in post) ? post.group?._id : post.groupId;	50!
246	if (!user \|\| !groupId)	50!
247	return false	50✔
248
249	const group = context	×
250	? await context.loaders.Localgroups.load(groupId)	×
251	: await Localgroups.findOne({_id: groupId});
252	return !!group && group.organizerIds.some(id => id === user._id);	×
253	}
254
255	/**
256	* Whether the user can make updates to the post document (including both the main post body and most other post fields)
257	*/
258	export const canUserEditPostMetadata = (currentUser: UsersCurrent\|DbUser\|null, post: PostsBase\|DbPost): boolean => {	26✔
259	if (!currentUser) return false;	8!
260
261	const organizerIds = (post as PostsBase)?.group?.organizerIds;	8!
262	const isPostGroupOrganizer = organizerIds ? organizerIds.some(id => id === currentUser?._id) : false;	8!
263	if (isPostGroupOrganizer) return true	8!
264
265	if (userOwns(currentUser, post)) return true	8✔
266	if (userCanDo(currentUser, 'posts.edit.all')) return true	3✔
267	// Shared as a coauthor? Always give access
268	if (post.coauthorStatuses && post.coauthorStatuses.findIndex(({ userId }) => userId === currentUser._id) >= 0) return true	2!
269
270	if (userIsSharedOn(currentUser, post) && post.sharingSettings?.anyoneWithLinkCan === "edit") return true	2!
271
272	if (post.shareWithUsers?.includes(currentUser._id) && post.sharingSettings?.explicitlySharedUsersCan === "edit") return true	2!
273
274	return false	2✔
275	}
276
277	export const postCanDelete = (currentUser: UsersCurrent\|null, post: PostsBase): boolean => {	26✔
278	if (userCanDo(currentUser, "posts.remove.all")) {	×
279	return true	×
280	}
281	const organizerIds = post.group?.organizerIds;	×
282	const isPostGroupOrganizer = organizerIds ? organizerIds.some(id => id === currentUser?._id) : false;	×
283	return (userOwns(currentUser, post) \|\| isPostGroupOrganizer) && post.draft	×
284	}
285
286	export const postGetKarma = (post: PostsBase\|DbPost): number => {	26✔
287	const baseScore = isAF ? post.afBaseScore : post.baseScore	×
288	return baseScore \|\| 0	×
289	}
290
291	// User can add/edit the hideCommentKarma setting if:
292	// 1) The user is logged in and has the requisite setting enabled
293	// And
294	// 2) The post does not exist yet
295	// Or if the post does exist
296	// 3) The post doesn't have any comments yet
297	export const postCanEditHideCommentKarma = (user: UsersCurrent\|DbUser\|null, post?: PostsBase\|DbPost\|null): boolean => {	26✔
298	return !!(user?.showHideKarmaOption && (!post \|\| !postGetCommentCount(post)))	×
299	}
300
301	export type CoauthoredPost = Partial<Pick<DbPost, "hasCoauthorPermission" \| "coauthorStatuses">>
302
303	export const postCoauthorIsPending = (post: CoauthoredPost, coauthorUserId: string) => {	26✔
304	if (post.hasCoauthorPermission) {	×
305	return false;	×
306	}
307	const status = post.coauthorStatuses?.find(({ userId }) => coauthorUserId === userId);	×
308	return status && !status.confirmed;	×
309	}
310
311	export const getConfirmedCoauthorIds = (post: CoauthoredPost): string[] => {	26✔
312	let { coauthorStatuses, hasCoauthorPermission = true } = post;	265!
313	if (!coauthorStatuses) return []	265✔
314
315	if (!hasCoauthorPermission) {	7!
316	coauthorStatuses = coauthorStatuses.filter(({ confirmed }) => confirmed);	×
317	}
318	return coauthorStatuses.map(({ userId }) => userId);	7✔
319	}
320
321	export const userIsPostCoauthor = (user: UsersMinimumInfo\|DbUser\|null, post: CoauthoredPost): boolean => {	26✔
322	if (!user) {	4!
UNCOV 323	return false;	×
324	}
325	const userIds = getConfirmedCoauthorIds(post);	4✔
326	return userIds.indexOf(user._id) >= 0;	4✔
327	}
328
329	export const isNotHostedHere = (post: PostsPage\|DbPost) => {	26✔
330	return post?.fmCrosspost?.isCrosspost && !post?.fmCrosspost?.hostedHere	×
331	}
332
333	const mostRelevantTag = (	26✔
334	tags: TagPreviewFragment[],
335	tagRelevance: Record<string, number>,	×
336	): TagPreviewFragment \| null => max(tags, ({_id}) => tagRelevance[_id] ?? 0);	×
337
338	export const postGetPrimaryTag = (post: PostsListWithVotes, includeNonCore = false) => {	26!
339	const {tags, tagRelevance} = post;	×
340	const core = tags.filter(({core}) => core);	×
341	const potentialTags = core.length < 1 && includeNonCore ? tags : core;	×
342	const result = mostRelevantTag(potentialTags, tagRelevance);	×
343	return typeof result === "object" ? result : undefined;	×
344	}
345
346	const allowTypeIIIPlayerSetting = new PublicInstanceSetting<boolean>('allowTypeIIIPlayer', false, "optional")	26✔
347	const type3DateCutoffSetting = new DatabasePublicSetting<string>('type3.cutoffDate', '2023-05-01')	26✔
348	const type3ExplicitlyAllowedPostIdsSetting = new DatabasePublicSetting<string[]>('type3.explicitlyAllowedPostIds', [])	26✔
349	/** type3KarmaCutoffSetting is here to allow including high karma posts from before type3DateCutoffSetting */
350	const type3KarmaCutoffSetting = new DatabasePublicSetting<number>('type3.karmaCutoff', Infinity)	26✔
351
352	/**
353	* Whether the post is allowed AI generated audio
354	*/
355	export const isPostAllowedType3Audio = (post: PostsBase\|DbPost): boolean => {	26✔
356	if (!allowTypeIIIPlayerSetting.get()) return false	×
357
358	try {	×
359	const TYPE_III_DATE_CUTOFF = new Date(type3DateCutoffSetting.get())	×
360	const TYPE_III_ALLOWED_POST_IDS = type3ExplicitlyAllowedPostIdsSetting.get()	×
361
362	return (	×
363	(new Date(post.postedAt) >= TYPE_III_DATE_CUTOFF \|\|	×
364	TYPE_III_ALLOWED_POST_IDS.includes(post._id) \|\|
365	post.baseScore > type3KarmaCutoffSetting.get() \|\|
366	post.forceAllowType3Audio) &&
367	!post.draft &&
368	!post.authorIsUnreviewed &&
369	!post.rejected &&
370	!post.podcastEpisodeId &&
371	!post.isEvent &&
372	!post.question &&
373	!post.debate &&
374	!post.shortform &&
375	post.status === postStatuses.STATUS_APPROVED
376	);
377	} catch (e) {
378	// eslint-disable-next-line no-console
379	console.error(e)	×
380	return false	×
381	}
382	}
383
384	/**
385	* Given a url like https://docs.google.com/document/d/1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA/edit#heading=h.82kaw9idgbpe
386	* return just the id part (1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA in this case)
387	*/
388	export const extractGoogleDocId = (urlOrId: string): string \| null => {	26✔
389	const docIdMatch = urlOrId.match(/.docs\.google\.com.\/d\/(.+?)(\/\|$)/);	×
390	return docIdMatch ? docIdMatch[1] : null;	×
391	};
392
393	/**
394	* Given a Google doc id like 1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA, return
395	* the full url (as if you were able to edit it). In this case it would be
396	* https://docs.google.com/document/d/1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA/edit
397	*/
398	export const googleDocIdToUrl = (docId: string): string => {	26✔
399	return `https://docs.google.com/document/d/${docId}/edit`;	×
400	};
401
402	export const postRouteWillDefinitelyReturn200 = async (req: Request, res: Response, parsedRoute: RouterLocation, context: ResolverContext) => {	26✔
403	const matchPostPath = pathToRegexp('/posts/:_id/:slug?');	×
404	const [_, postId] = matchPostPath.exec(req.path) ?? [];	×
405
406	if (postId) {	×
407	if (req.query.commentId && commentPermalinkStyleSetting.get() === 'in-context') {	×
408	// Will redirect from ?commentId=... to #...
409	return false;	×
410	}
411
412	return await context.repos.posts.postRouteWillDefinitelyReturn200(postId);	×
413	}
414	return false;	×
415	}
416
417	export const isRecombeeRecommendablePost = (post: DbPost \| PostsBase): boolean => {	26✔
418	// We explicitly don't check `isFuture` here, because the cron job that "publishes" those posts does a raw update
419	// So it won't trigger any of the callbacks, and if we exclude those posts they'll never get recommended
420	// `Posts.checkAccess` already filters out posts with `isFuture` unless you're a mod or otherwise own the post
421	// So we're not really in any danger of showing those posts to regular users
422	// TODO: figure out how to handle this more gracefully
423	return !(	124✔
424	post.shortform	981✔
425	\|\| post.unlisted
426	\|\| post.rejected
427	\|\| post.isEvent
428	\|\| !!post.groupId
429	\|\| post.disableRecommendation
430	\|\| post.status !== 2
431	\|\| post._id === aboutPostIdSetting.get()
432	);
433	};

ForumMagnum / ForumMagnum / 10709183381

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