8691824346

Committed 15 Apr 2024 03:24PM UTC coverage: 31.982% (-0.005%) from 31.987%

Build # 8691824346

Build Type

Pull #9114

github

Committed by

Will-Howard

Commit Message

allow setting the same status code

Pull Request Pull Request #9114: Prefetch resources on most post pages

Run Details

4645 of 37823 branches covered (12.28%)

Branch coverage included in aggregate %.

8 of 37 new or added lines in 4 files covered. (21.62%)

2 existing lines in 1 file now uncovered.

27055 of 61295 relevant lines covered (44.14%)

182.82 hits per line

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

30.07

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

import { PublicInstanceSetting, isAF, 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 } from '../../publicSettings';
import Localgroups from '../localgroups/collection';
import moment from '../../moment-timezone';
import { max } from "underscore";
import { TupleSet, UnionOf } from '../../utils/typeGuardUtils';
import type { Request, Response } from 'express';
import pathToRegexp from "path-to-regexp";

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

/**
 * Returns the event datetimes in a user-friendly format,
 * ex: Mon, Jan 3 at 4:30 - 5:30 PM
 * 
 * @param {(PostsBase|DbPost)} post - The event to be checked.
 * @param {string} [timezone] - (Optional) Convert datetimes to this timezone.
 * @param {string} [dense] - (Optional) Exclude the day of the week.
 * @returns {string} The formatted event datetimes.
 */
export const prettyEventDateTimes = (post: PostsBase|DbPost, timezone?: string, dense?: boolean): string => {
  // when no start time, just show "TBD"
  if (!post.startTime) return 'TBD'
  
  let start = moment(post.startTime)
  let end = post.endTime && moment(post.endTime)
  // if we have event times in the local timezone, use those instead
  const useLocalTimes = post.localStartTime && (!post.endTime || post.localEndTime)

  // prefer to use the provided timezone
  let tz = ` ${start.format('[UTC]ZZ')}`
  if (timezone) {
    start = start.tz(timezone)
    end = end && end.tz(timezone)
    tz = ` ${start.format('z')}`
  } else if (useLocalTimes) {
    // see postResolvers.ts for more on how local times work
    start = moment(post.localStartTime).utc()
    end = post.localEndTime && moment(post.localEndTime).utc()
    tz = ''
  }
  
  // hide the year if it's reasonable to assume it
  const now = moment()
  const sixMonthsFromNow = moment().add(6, 'months')
  const startYear = (now.isSame(start, 'year') || start.isBefore(sixMonthsFromNow)) ? '' : `, ${start.format('YYYY')}`
  
  const startDate = dense ? start.format('MMM D') : start.format('ddd, MMM D')
  const startTime = start.format('h:mm').replace(':00', '')
  let startAmPm = ` ${start.format('A')}`
  
  if (!end) {
    // just a start time
    // ex: Starts on Mon, Jan 3 at 4:30 PM
    // ex: Starts on Mon, Jan 3, 2023 at 4:30 PM EST
    return `${dense ? '' : 'Starts on '}${startDate}${startYear} at ${startTime}${startAmPm}${tz}`
  }

  const endTime = end.format('h:mm A').replace(':00', '')
  // start and end time on the same day
  // ex: Mon, Jan 3 at 4:30 - 5:30 PM
  // ex: Mon, Jan 3, 2023 at 4:30 - 5:30 PM EST
  if (start.isSame(end, 'day')) {
    // hide the start time am/pm if it's the same as the end time's
    startAmPm = start.format('A') === end.format('A') ? '' : startAmPm
    return `${startDate}${startYear} at ${startTime}${startAmPm} - ${endTime}${tz}`
  }

  // start and end time on different days
  // ex: Mon, Jan 3 at 4:30 PM - Tues, Jan 4 at 5:30 PM
  // ex: Mon, Jan 3, 2023 at 4:30 PM - Tues, Jan 4, 2023 at 5:30 PM EST
  const endDate = dense ? end.format('MMM D') : end.format('ddd, MMM D')
  const endYear = (now.isSame(end, 'year') || end.isBefore(sixMonthsFromNow)) ? '' : `, ${end.format('YYYY')}`
  return `${startDate}${startYear} at ${startTime}${startAmPm} - ${endDate}${endYear} at ${endTime}${tz}`
}

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, context: ResolverContext) => {
  const matchPostPath = pathToRegexp('/posts/:_id/:slug?');
  const [_, postId] = matchPostPath.exec(req.path) ?? [];

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

1	import { PublicInstanceSetting, isAF, siteUrlSetting } from '../../instanceSettings';	713✔
2	import { getOutgoingUrl, getSiteUrl } from '../../vulcan-lib/utils';	23✔
3	import { mongoFindOne } from '../../mongoQueries';	23✔
4	import { userOwns, userCanDo } from '../../vulcan-users/permissions';	23✔
5	import { userGetDisplayName, userIsSharedOn } from '../users/helpers';	23✔
6	import { postStatuses, postStatusLabels } from './constants';	23✔
7	import { DatabasePublicSetting, cloudinaryCloudNameSetting } from '../../publicSettings';	23✔
8	import Localgroups from '../localgroups/collection';	23✔
9	import moment from '../../moment-timezone';	23✔
10	import { max } from "underscore";	23✔
11	import { TupleSet, UnionOf } from '../../utils/typeGuardUtils';	23✔
12	import type { Request, Response } from 'express';
13	import pathToRegexp from "path-to-regexp";	23✔
14
15	export const postCategories = new TupleSet(['post', 'linkpost', 'question'] as const);	23✔
16	export type PostCategory = UnionOf<typeof postCategories>;
17	export const postDefaultCategory = 'post';	23✔
18	export const isPostCategory = (tab: string): tab is PostCategory => postCategories.has(tab)	23✔
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 {	23!
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 {	23✔
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> {	23✔
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 {	23✔
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]));	23✔
60
61	// Get status name
62	export const postGetStatusName = function (post: DbPost): string {	23✔
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 {	23✔
68	return post.status === postStatuses.STATUS_APPROVED;	45✔
69	};
70
71	// Get URL for sharing on Twitter.
72	export const postGetTwitterShareUrl = (post: DbPost): string => {	23✔
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 => {	23✔
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 => {	23✔
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 = () =>	23✔
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 => {	23✔
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(	23✔
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 {	23!
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 = (	23✔
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 {	23!
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 => {	23!
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 => {	23✔
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 => {	23✔
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 => {	23✔
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[] }) => {	23✔
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 => {	23✔
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 => {	23✔
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> => {	23✔
245	const groupId = ('group' in post) ? post.group?._id : post.groupId;	18!
246	if (!user \|\| !groupId)	18!
247	return false	18✔
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 => {	23✔
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 => {	23✔
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 => {	23✔
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 => {	23✔
298	return !!(user?.showHideKarmaOption && (!post \|\| !postGetCommentCount(post)))	×
299	}
300
301	/**
302	* Returns the event datetimes in a user-friendly format,
303	* ex: Mon, Jan 3 at 4:30 - 5:30 PM
304	*
305	* @param {(PostsBase\|DbPost)} post - The event to be checked.
306	* @param {string} [timezone] - (Optional) Convert datetimes to this timezone.
307	* @param {string} [dense] - (Optional) Exclude the day of the week.
308	* @returns {string} The formatted event datetimes.
309	*/
310	export const prettyEventDateTimes = (post: PostsBase\|DbPost, timezone?: string, dense?: boolean): string => {	23✔
311	// when no start time, just show "TBD"
312	if (!post.startTime) return 'TBD'	×
313
314	let start = moment(post.startTime)	×
315	let end = post.endTime && moment(post.endTime)	×
316	// if we have event times in the local timezone, use those instead
317	const useLocalTimes = post.localStartTime && (!post.endTime \|\| post.localEndTime)	×
318
319	// prefer to use the provided timezone
320	let tz = ` ${start.format('[UTC]ZZ')}`	×
321	if (timezone) {	×
322	start = start.tz(timezone)	×
323	end = end && end.tz(timezone)	×
324	tz = ` ${start.format('z')}`	×
325	} else if (useLocalTimes) {	×
326	// see postResolvers.ts for more on how local times work
327	start = moment(post.localStartTime).utc()	×
328	end = post.localEndTime && moment(post.localEndTime).utc()	×
329	tz = ''	×
330	}
331
332	// hide the year if it's reasonable to assume it
333	const now = moment()	×
334	const sixMonthsFromNow = moment().add(6, 'months')	×
335	const startYear = (now.isSame(start, 'year') \|\| start.isBefore(sixMonthsFromNow)) ? '' : `, ${start.format('YYYY')}`	×
336
337	const startDate = dense ? start.format('MMM D') : start.format('ddd, MMM D')	×
338	const startTime = start.format('h:mm').replace(':00', '')	×
339	let startAmPm = ` ${start.format('A')}`	×
340
341	if (!end) {	×
342	// just a start time
343	// ex: Starts on Mon, Jan 3 at 4:30 PM
344	// ex: Starts on Mon, Jan 3, 2023 at 4:30 PM EST
345	return `${dense ? '' : 'Starts on '}${startDate}${startYear} at ${startTime}${startAmPm}${tz}`	×
346	}
347
348	const endTime = end.format('h:mm A').replace(':00', '')	×
349	// start and end time on the same day
350	// ex: Mon, Jan 3 at 4:30 - 5:30 PM
351	// ex: Mon, Jan 3, 2023 at 4:30 - 5:30 PM EST
352	if (start.isSame(end, 'day')) {	×
353	// hide the start time am/pm if it's the same as the end time's
354	startAmPm = start.format('A') === end.format('A') ? '' : startAmPm	×
355	return `${startDate}${startYear} at ${startTime}${startAmPm} - ${endTime}${tz}`	×
356	}
357
358	// start and end time on different days
359	// ex: Mon, Jan 3 at 4:30 PM - Tues, Jan 4 at 5:30 PM
360	// ex: Mon, Jan 3, 2023 at 4:30 PM - Tues, Jan 4, 2023 at 5:30 PM EST
361	const endDate = dense ? end.format('MMM D') : end.format('ddd, MMM D')	×
362	const endYear = (now.isSame(end, 'year') \|\| end.isBefore(sixMonthsFromNow)) ? '' : `, ${end.format('YYYY')}`	×
363	return `${startDate}${startYear} at ${startTime}${startAmPm} - ${endDate}${endYear} at ${endTime}${tz}`	×
364	}
365
366	export type CoauthoredPost = Partial<Pick<DbPost, "hasCoauthorPermission" \| "coauthorStatuses">>
367
368	export const postCoauthorIsPending = (post: CoauthoredPost, coauthorUserId: string) => {	23✔
369	if (post.hasCoauthorPermission) {	×
370	return false;	×
371	}
372	const status = post.coauthorStatuses?.find(({ userId }) => coauthorUserId === userId);	×
373	return status && !status.confirmed;	×
374	}
375
376	export const getConfirmedCoauthorIds = (post: CoauthoredPost): string[] => {	23✔
377	let { coauthorStatuses, hasCoauthorPermission = true } = post;	261!
378	if (!coauthorStatuses) return []	261✔
379
380	if (!hasCoauthorPermission) {	7!
381	coauthorStatuses = coauthorStatuses.filter(({ confirmed }) => confirmed);	×
382	}
383	return coauthorStatuses.map(({ userId }) => userId);	7✔
384	}
385
386	export const userIsPostCoauthor = (user: UsersMinimumInfo\|DbUser\|null, post: CoauthoredPost): boolean => {	23✔
387	if (!user) {	×
388	return false;	×
389	}
390	const userIds = getConfirmedCoauthorIds(post);	×
391	return userIds.indexOf(user._id) >= 0;	×
392	}
393
394	export const isNotHostedHere = (post: PostsPage\|DbPost) => {	23✔
395	return post?.fmCrosspost?.isCrosspost && !post?.fmCrosspost?.hostedHere	×
396	}
397
398	const mostRelevantTag = (	23✔
399	tags: TagPreviewFragment[],
400	tagRelevance: Record<string, number>,	×
401	): TagPreviewFragment \| null => max(tags, ({_id}) => tagRelevance[_id] ?? 0);	×
402
403	export const postGetPrimaryTag = (post: PostsListWithVotes, includeNonCore = false) => {	23!
404	const {tags, tagRelevance} = post;	×
405	const core = tags.filter(({core}) => core);	×
406	const potentialTags = core.length < 1 && includeNonCore ? tags : core;	×
407	const result = mostRelevantTag(potentialTags, tagRelevance);	×
408	return typeof result === "object" ? result : undefined;	×
409	}
410
411	const allowTypeIIIPlayerSetting = new PublicInstanceSetting<boolean>('allowTypeIIIPlayer', false, "optional")	23✔
412	const type3DateCutoffSetting = new DatabasePublicSetting<string>('type3.cutoffDate', '2023-05-01')	23✔
413	const type3ExplicitlyAllowedPostIdsSetting = new DatabasePublicSetting<string[]>('type3.explicitlyAllowedPostIds', [])	23✔
414	/** type3KarmaCutoffSetting is here to allow including high karma posts from before type3DateCutoffSetting */
415	const type3KarmaCutoffSetting = new DatabasePublicSetting<number>('type3.karmaCutoff', Infinity)	23✔
416
417	/**
418	* Whether the post is allowed AI generated audio
419	*/
420	export const isPostAllowedType3Audio = (post: PostsBase\|DbPost): boolean => {	23✔
421	if (!allowTypeIIIPlayerSetting.get()) return false	×
422
423	try {	×
424	const TYPE_III_DATE_CUTOFF = new Date(type3DateCutoffSetting.get())	×
425	const TYPE_III_ALLOWED_POST_IDS = type3ExplicitlyAllowedPostIdsSetting.get()	×
426
427	return (	×
428	(new Date(post.postedAt) >= TYPE_III_DATE_CUTOFF \|\|	×
429	TYPE_III_ALLOWED_POST_IDS.includes(post._id) \|\|
430	post.baseScore > type3KarmaCutoffSetting.get() \|\|
431	post.forceAllowType3Audio) &&
432	!post.draft &&
433	!post.authorIsUnreviewed &&
434	!post.rejected &&
435	!post.podcastEpisodeId &&
436	!post.isEvent &&
437	!post.question &&
438	!post.debate &&
439	!post.shortform &&
440	post.status === postStatuses.STATUS_APPROVED
441	);
442	} catch (e) {
443	// eslint-disable-next-line no-console
444	console.error(e)	×
445	return false	×
446	}
447	}
448
449	/**
450	* Given a url like https://docs.google.com/document/d/1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA/edit#heading=h.82kaw9idgbpe
451	* return just the id part (1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA in this case)
452	*/
453	export const extractGoogleDocId = (urlOrId: string): string \| null => {	23✔
454	const docIdMatch = urlOrId.match(/.docs\.google\.com.\/d\/(.+?)(\/\|$)/);	×
455	return docIdMatch ? docIdMatch[1] : null;	×
456	};
457
458	/**
459	* Given a Google doc id like 1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA, return
460	* the full url (as if you were able to edit it). In this case it would be
461	* https://docs.google.com/document/d/1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA/edit
462	*/
463	export const googleDocIdToUrl = (docId: string): string => {	23✔
464	return `https://docs.google.com/document/d/${docId}/edit`;	×
465	};
466
467	export const postRouteWillDefinitelyReturn200 = async (req: Request, res: Response, context: ResolverContext) => {	23✔
NEW 468	const matchPostPath = pathToRegexp('/posts/:_id/:slug?');	×
NEW 469	const [_, postId] = matchPostPath.exec(req.path) ?? [];	×
470
NEW 471	if (postId) {	×
NEW 472	return await context.repos.posts.postRouteWillDefinitelyReturn200(postId);	×
473	}
NEW 474	return false;	×
475	}

ForumMagnum / ForumMagnum / 8691824346

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