10276828451

Committed 07 Aug 2024 01:59AM UTC coverage: 32.058% (-0.002%) from 32.06%

Build # 10276828451

Build Type

Pull #9556

github

Committed by

Raemon

Commit Message

post-type tag styling in posts page header

Pull Request Pull Request #9556: Minimalist Post Header

Run Details

4938 of 40113 branches covered (12.31%)

Branch coverage included in aggregate %.

47 of 107 new or added lines in 17 files covered. (43.93%)

2 existing lines in 2 files now uncovered.

28755 of 64987 relevant lines covered (44.25%)

180.59 hits per line

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

35.53

/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) {
    if (isLWorAF) {
      return "0 comments";
    } else {
      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';	859✔
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) {	×
NEW 191	if (isLWorAF) {	×
NEW 192	return "0 comments";	×
193	} else {
NEW 194	return "No comments";	×
195	}
196	} else if (count === 1) {	×
197	return "1 comment";	×
198	} else {
199	return count + " comments";	×
200	}
201	}
202
203	export const postGetAnswerCountStr = (count: number): string => {	26✔
204	if (!count) {	×
205	return "No answers";	×
206	} else if (count === 1) {	×
207	return "1 answer";	×
208	} else {
209	return count + " answers";	×
210	}
211	}
212
213	export const getResponseCounts = ({ post, answers }: { post: PostWithCommentCounts; answers: CommentsList[] }) => {	26✔
214	// answers may include some which are deleted:true, deletedPublic:true (in which
215	// case various fields are unpopulated and a deleted-item placeholder is shown
216	// in the UI). These deleted answers are not included in post.commentCount.
217	const nonDeletedAnswers = answers.filter((answer) => !answer.deleted);	×
218
219	const answerAndDescendentsCount =
220	answers.reduce((prev: number, curr: CommentsList) => prev + curr.descendentCount, 0) + answers.length;	×
221
222	return {	×
223	answerCount: nonDeletedAnswers.length,
224	commentCount: postGetCommentCount(post) - answerAndDescendentsCount,
225	};
226	};
227
228	export const postGetLastCommentedAt = (post: PostsBase\|DbPost): Date \| null => {	26✔
229	if (isAF) {	×
230	return post.afLastCommentedAt;	×
231	} else {
232	return post.lastCommentedAt;	×
233	}
234	}
235
236	export const postGetLastCommentPromotedAt = (post: PostsBase\|DbPost): Date\|null => {	26✔
237	if (isAF) return null	×
238	// TODO: add an afLastCommentPromotedAt
239	return post.lastCommentPromotedAt;	×
240	}
241
242	/**
243	* Whether or not the given user is an organizer for the post's group
244	* @param user
245	* @param post
246	* @returns {Promise} Promise object resolves to true if the post has a group and the user is an organizer for that group
247	*/
248	export const userIsPostGroupOrganizer = async (user: UsersMinimumInfo\|DbUser\|null, post: PostsBase\|DbPost, context: ResolverContext\|null): Promise<boolean> => {	26✔
249	const groupId = ('group' in post) ? post.group?._id : post.groupId;	18!
250	if (!user \|\| !groupId)	18!
251	return false	18✔
252
253	const group = context	×
254	? await context.loaders.Localgroups.load(groupId)	×
255	: await Localgroups.findOne({_id: groupId});
256	return !!group && group.organizerIds.some(id => id === user._id);	×
257	}
258
259	/**
260	* Whether the user can make updates to the post document (including both the main post body and most other post fields)
261	*/
262	export const canUserEditPostMetadata = (currentUser: UsersCurrent\|DbUser\|null, post: PostsBase\|DbPost): boolean => {	26✔
263	if (!currentUser) return false;	8!
264
265	const organizerIds = (post as PostsBase)?.group?.organizerIds;	8!
266	const isPostGroupOrganizer = organizerIds ? organizerIds.some(id => id === currentUser?._id) : false;	8!
267	if (isPostGroupOrganizer) return true	8!
268
269	if (userOwns(currentUser, post)) return true	8✔
270	if (userCanDo(currentUser, 'posts.edit.all')) return true	3✔
271	// Shared as a coauthor? Always give access
272	if (post.coauthorStatuses && post.coauthorStatuses.findIndex(({ userId }) => userId === currentUser._id) >= 0) return true	2!
273
274	if (userIsSharedOn(currentUser, post) && post.sharingSettings?.anyoneWithLinkCan === "edit") return true	2!
275
276	if (post.shareWithUsers?.includes(currentUser._id) && post.sharingSettings?.explicitlySharedUsersCan === "edit") return true	2!
277
278	return false	2✔
279	}
280
281	export const postCanDelete = (currentUser: UsersCurrent\|null, post: PostsBase): boolean => {	26✔
282	if (userCanDo(currentUser, "posts.remove.all")) {	×
283	return true	×
284	}
285	const organizerIds = post.group?.organizerIds;	×
286	const isPostGroupOrganizer = organizerIds ? organizerIds.some(id => id === currentUser?._id) : false;	×
287	return (userOwns(currentUser, post) \|\| isPostGroupOrganizer) && post.draft	×
288	}
289
290	export const postGetKarma = (post: PostsBase\|DbPost): number => {	26✔
291	const baseScore = isAF ? post.afBaseScore : post.baseScore	×
292	return baseScore \|\| 0	×
293	}
294
295	// User can add/edit the hideCommentKarma setting if:
296	// 1) The user is logged in and has the requisite setting enabled
297	// And
298	// 2) The post does not exist yet
299	// Or if the post does exist
300	// 3) The post doesn't have any comments yet
301	export const postCanEditHideCommentKarma = (user: UsersCurrent\|DbUser\|null, post?: PostsBase\|DbPost\|null): boolean => {	26✔
302	return !!(user?.showHideKarmaOption && (!post \|\| !postGetCommentCount(post)))	×
303	}
304
305	export type CoauthoredPost = Partial<Pick<DbPost, "hasCoauthorPermission" \| "coauthorStatuses">>
306
307	export const postCoauthorIsPending = (post: CoauthoredPost, coauthorUserId: string) => {	26✔
308	if (post.hasCoauthorPermission) {	×
309	return false;	×
310	}
311	const status = post.coauthorStatuses?.find(({ userId }) => coauthorUserId === userId);	×
312	return status && !status.confirmed;	×
313	}
314
315	export const getConfirmedCoauthorIds = (post: CoauthoredPost): string[] => {	26✔
316	let { coauthorStatuses, hasCoauthorPermission = true } = post;	261!
317	if (!coauthorStatuses) return []	261✔
318
319	if (!hasCoauthorPermission) {	7!
320	coauthorStatuses = coauthorStatuses.filter(({ confirmed }) => confirmed);	×
321	}
322	return coauthorStatuses.map(({ userId }) => userId);	7✔
323	}
324
325	export const userIsPostCoauthor = (user: UsersMinimumInfo\|DbUser\|null, post: CoauthoredPost): boolean => {	26✔
326	if (!user) {	×
327	return false;	×
328	}
329	const userIds = getConfirmedCoauthorIds(post);	×
330	return userIds.indexOf(user._id) >= 0;	×
331	}
332
333	export const isNotHostedHere = (post: PostsPage\|DbPost) => {	26✔
334	return post?.fmCrosspost?.isCrosspost && !post?.fmCrosspost?.hostedHere	×
335	}
336
337	const mostRelevantTag = (	26✔
338	tags: TagPreviewFragment[],
339	tagRelevance: Record<string, number>,	×
340	): TagPreviewFragment \| null => max(tags, ({_id}) => tagRelevance[_id] ?? 0);	×
341
342	export const postGetPrimaryTag = (post: PostsListWithVotes, includeNonCore = false) => {	26!
343	const {tags, tagRelevance} = post;	×
344	const core = tags.filter(({core}) => core);	×
345	const potentialTags = core.length < 1 && includeNonCore ? tags : core;	×
346	const result = mostRelevantTag(potentialTags, tagRelevance);	×
347	return typeof result === "object" ? result : undefined;	×
348	}
349
350	const allowTypeIIIPlayerSetting = new PublicInstanceSetting<boolean>('allowTypeIIIPlayer', false, "optional")	26✔
351	const type3DateCutoffSetting = new DatabasePublicSetting<string>('type3.cutoffDate', '2023-05-01')	26✔
352	const type3ExplicitlyAllowedPostIdsSetting = new DatabasePublicSetting<string[]>('type3.explicitlyAllowedPostIds', [])	26✔
353	/** type3KarmaCutoffSetting is here to allow including high karma posts from before type3DateCutoffSetting */
354	const type3KarmaCutoffSetting = new DatabasePublicSetting<number>('type3.karmaCutoff', Infinity)	26✔
355
356	/**
357	* Whether the post is allowed AI generated audio
358	*/
359	export const isPostAllowedType3Audio = (post: PostsBase\|DbPost): boolean => {	26✔
360	if (!allowTypeIIIPlayerSetting.get()) return false	×
361
362	try {	×
363	const TYPE_III_DATE_CUTOFF = new Date(type3DateCutoffSetting.get())	×
364	const TYPE_III_ALLOWED_POST_IDS = type3ExplicitlyAllowedPostIdsSetting.get()	×
365
366	return (	×
367	(new Date(post.postedAt) >= TYPE_III_DATE_CUTOFF \|\|	×
368	TYPE_III_ALLOWED_POST_IDS.includes(post._id) \|\|
369	post.baseScore > type3KarmaCutoffSetting.get() \|\|
370	post.forceAllowType3Audio) &&
371	!post.draft &&
372	!post.authorIsUnreviewed &&
373	!post.rejected &&
374	!post.podcastEpisodeId &&
375	!post.isEvent &&
376	!post.question &&
377	!post.debate &&
378	!post.shortform &&
379	post.status === postStatuses.STATUS_APPROVED
380	);
381	} catch (e) {
382	// eslint-disable-next-line no-console
383	console.error(e)	×
384	return false	×
385	}
386	}
387
388	/**
389	* Given a url like https://docs.google.com/document/d/1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA/edit#heading=h.82kaw9idgbpe
390	* return just the id part (1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA in this case)
391	*/
392	export const extractGoogleDocId = (urlOrId: string): string \| null => {	26✔
393	const docIdMatch = urlOrId.match(/.docs\.google\.com.\/d\/(.+?)(\/\|$)/);	×
394	return docIdMatch ? docIdMatch[1] : null;	×
395	};
396
397	/**
398	* Given a Google doc id like 1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA, return
399	* the full url (as if you were able to edit it). In this case it would be
400	* https://docs.google.com/document/d/1G4SNqovdoEHaHca20TPJA6D4Ck7Yo8ocvKdwdZdL5qA/edit
401	*/
402	export const googleDocIdToUrl = (docId: string): string => {	26✔
403	return `https://docs.google.com/document/d/${docId}/edit`;	×
404	};
405
406	export const postRouteWillDefinitelyReturn200 = async (req: Request, res: Response, parsedRoute: RouterLocation, context: ResolverContext) => {	26✔
407	const matchPostPath = pathToRegexp('/posts/:_id/:slug?');	×
408	const [_, postId] = matchPostPath.exec(req.path) ?? [];	×
409
410	if (postId) {	×
411	if (req.query.commentId && commentPermalinkStyleSetting.get() === 'in-context') {	×
412	// Will redirect from ?commentId=... to #...
413	return false;	×
414	}
415
416	return await context.repos.posts.postRouteWillDefinitelyReturn200(postId);	×
417	}
418	return false;	×
419	}
420
421	export const isRecombeeRecommendablePost = (post: DbPost \| PostsBase): boolean => {	26✔
422	// We explicitly don't check `isFuture` here, because the cron job that "publishes" those posts does a raw update
423	// So it won't trigger any of the callbacks, and if we exclude those posts they'll never get recommended
424	// `Posts.checkAccess` already filters out posts with `isFuture` unless you're a mod or otherwise own the post
425	// So we're not really in any danger of showing those posts to regular users
426	// TODO: figure out how to handle this more gracefully
427	return !(	124✔
428	post.shortform	981✔
429	\|\| post.unlisted
430	\|\| post.rejected
431	\|\| post.isEvent
432	\|\| !!post.groupId
433	\|\| post.disableRecommendation
434	\|\| post.status !== 2
435	\|\| post._id === aboutPostIdSetting.get()
436	);
437	};

ForumMagnum / ForumMagnum / 10276828451

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