9604073582

Committed 20 Jun 2024 08:39PM UTC coverage: 15.012% (+0.006%) from 15.006%

Build # 9604073582

Build Type

Pull #8200

github

Committed by

web-flow

Commit Message

Merge bc12f5aed into f096fad97

Pull Request Pull Request #8200: Fix relayer notify bug

Run Details

3722 of 26275 branches covered (14.17%)

Branch coverage included in aggregate %.

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

126 existing lines in 25 files now uncovered.

5153 of 32845 relevant lines covered (15.69%)

5.02 hits per line

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

50.44

/packages/commonwealth/server/controllers/server_threads_methods/create_thread.ts

import { PermissionEnum } from '@hicommonwealth/schemas';
import moment from 'moment';

import { AppError } from '@hicommonwealth/core';
import {
  AddressInstance,
  CommunityInstance,
  ThreadAttributes,
  UserInstance,
} from '@hicommonwealth/model';
import { NotificationCategories, ProposalType } from '@hicommonwealth/shared';
import { sanitizeQuillText } from 'server/util/sanitizeQuillText';
import { MixpanelCommunityInteractionEvent } from '../../../shared/analytics/types';
import { renderQuillDeltaToText } from '../../../shared/utils';
import {
  createThreadMentionNotifications,
  emitMentions,
  parseUserMentions,
  queryMentionedUsers,
  uniqueMentions,
} from '../../util/parseUserMentions';
import { validateTopicGroupsMembership } from '../../util/requirementsModule/validateTopicGroupsMembership';
import { validateOwner } from '../../util/validateOwner';
import { TrackOptions } from '../server_analytics_controller';
import { EmitOptions } from '../server_notifications_methods/emit';
import { ServerThreadsController } from '../server_threads_controller';

export const Errors = {
  InsufficientTokenBalance: 'Insufficient token balance',
  BalanceCheckFailed: 'Could not verify user token balance',
  ParseMentionsFailed: 'Failed to parse mentions',
  LinkMissingTitleOrUrl: 'Links must include a title and URL',
  UnsupportedKind: 'Only discussion and link posts supported',
  FailedCreateThread: 'Failed to create thread',
  DiscussionMissingTitle: 'Discussion posts must include a title',
  NoBody: 'Thread body cannot be blank',
};

export type CreateThreadOptions = {
  user: UserInstance;
  address: AddressInstance;
  community: CommunityInstance;
  title: string;
  body: string;
  kind: string;
  readOnly: boolean;
  topicId?: number;
  stage?: string;
  url?: string;
  canvasSignedData?: string;
  canvasHash?: string;
  discordMeta?: any;
};

export type CreateThreadResult = [
  ThreadAttributes,
  EmitOptions[],
  TrackOptions,
];

export async function __createThread(
  this: ServerThreadsController,
  {
    user,
    address,
    community,
    title,
    body,
    kind,
    readOnly,
    topicId,
    stage,
    url,
    canvasSignedData,
    canvasHash,
    discordMeta,
  }: CreateThreadOptions,
): Promise<CreateThreadResult> {
  // sanitize text
  body = sanitizeQuillText(body);

  if (kind === 'discussion') {
    if (!title || !title.trim()) {
      throw new AppError(Errors.DiscussionMissingTitle);
    }
    try {
      const quillDoc = JSON.parse(decodeURIComponent(body));
      if (quillDoc.ops.length === 1 && quillDoc.ops[0].insert.trim() === '') {
        throw new AppError(Errors.NoBody);
      }
    } catch (e) {
      // check always passes if the body isn't a Quill document
    }
  } else if (kind === 'link') {
    if (!title?.trim() || !url?.trim()) {
      throw new AppError(Errors.LinkMissingTitleOrUrl);
    }
  } else {
    throw new AppError(Errors.UnsupportedKind);
  }

  // check if banned
  const [canInteract, banError] = await this.banCache.checkBan({
    communityId: community.id,
    address: address.address,
  });
  if (!canInteract) {
    throw new AppError(`Ban error: ${banError}`);
  }

  // Render a copy of the thread to plaintext for the search indexer
  const plaintext = (() => {
    try {
      return renderQuillDeltaToText(JSON.parse(decodeURIComponent(body)));
    } catch (e) {
      return decodeURIComponent(body);
    }
  })();

  // New threads get an empty version history initialized, which is passed
  // the thread's first version, formatted on the frontend with timestamps
  const firstVersion: any = {
    timestamp: moment(),
    author: address,
    body: decodeURIComponent(body),
  };
  const version_history: string[] = [JSON.stringify(firstVersion)];

  const threadContent: Partial<ThreadAttributes> = {
    community_id: community.id,
    address_id: address.id,
    title,
    body,
    plaintext,
    version_history,
    kind,
    stage,
    url,
    read_only: readOnly,
    canvas_signed_data: canvasSignedData,
    canvas_hash: canvasHash,
    discord_meta: discordMeta,
    // @ts-expect-error StrictNullChecks
    topic_id: +topicId,
  };

  const isAdmin = await validateOwner({
    models: this.models,
    user,
    // @ts-expect-error StrictNullChecks
    communityId: community.id,
    allowAdmin: true,
    allowSuperAdmin: true,
  });
  if (!isAdmin) {
    const { isValid, message } = await validateTopicGroupsMembership(
      this.models,
      // @ts-expect-error StrictNullChecks
      topicId,
      community.id,
      address,
      PermissionEnum.CREATE_THREAD,
    );
    if (!isValid) {
      throw new AppError(`${Errors.FailedCreateThread}: ${message}`);
    }
  }

  const bodyText = decodeURIComponent(body);
  const mentions = uniqueMentions(parseUserMentions(bodyText));
  const mentionedAddresses = await queryMentionedUsers(mentions, this.models);

  // begin essential database changes within transaction
  const newThreadId = await this.models.sequelize.transaction(
    async (transaction) => {
      // @ts-expect-error StrictNullChecks
      const thread = await this.models.Thread.create(threadContent, {
        transaction,
      });

      address.last_active = new Date();
      await address.save({ transaction });

      await emitMentions(this.models, transaction, {
        // @ts-expect-error StrictNullChecks
        authorAddressId: address.id,
        // @ts-expect-error StrictNullChecks
        authorUserId: user.id,
        authorAddress: address.address,
        // @ts-expect-error StrictNullChecks
        authorProfileId: address.profile_id,
        mentions: mentionedAddresses,
        thread,
      });

      return thread.id;
      // end of transaction
    },
  );

  const finalThread = await this.models.Thread.findOne({
    where: { id: newThreadId },
    include: [
      { model: this.models.Address, as: 'Address' },
      { model: this.models.Topic, as: 'topic' },
    ],
  });

  // exit early on error, do not emit notifications
  if (!finalThread) {
    throw new AppError(Errors.FailedCreateThread);
  }

  // -----

  // auto-subscribe thread creator to comments & reactions
  await this.models.Subscription.bulkCreate([
    {
      // @ts-expect-error StrictNullChecks
      subscriber_id: user.id,
      category_id: NotificationCategories.NewComment,
      // @ts-expect-error StrictNullChecks
      thread_id: finalThread.id,
      community_id: finalThread.community_id,
      is_active: true,
    },
    {
      // @ts-expect-error StrictNullChecks
      subscriber_id: user.id,
      category_id: NotificationCategories.NewReaction,
      // @ts-expect-error StrictNullChecks
      thread_id: finalThread.id,
      community_id: finalThread.community_id,
      is_active: true,
    },
  ]);

  const allNotificationOptions: EmitOptions[] = [];

  allNotificationOptions.push(
    ...createThreadMentionNotifications(mentionedAddresses, finalThread),
  );

  allNotificationOptions.push({
    notification: {
      categoryId: NotificationCategories.NewThread,
      data: {
        created_at: new Date(),
        // @ts-expect-error StrictNullChecks
        thread_id: finalThread.id,
        root_type: ProposalType.Thread,
        root_title: finalThread.title,
        // @ts-expect-error StrictNullChecks
        comment_text: finalThread.body,
        community_id: finalThread.community_id,
        // @ts-expect-error StrictNullChecks
        author_address: finalThread.Address.address,
        // @ts-expect-error StrictNullChecks
        author_community_id: finalThread.Address.community_id,
      },
    },
    // @ts-expect-error StrictNullChecks
    excludeAddresses: [finalThread.Address.address],
  });

  const analyticsOptions = {
    event: MixpanelCommunityInteractionEvent.CREATE_THREAD,
    community: community.id,
    userId: user.id,
  };

  return [finalThread.toJSON(), allNotificationOptions, analyticsOptions];
}

1	import { PermissionEnum } from '@hicommonwealth/schemas';
2	import moment from 'moment';
3
4	import { AppError } from '@hicommonwealth/core';
5	import {
6	AddressInstance,
7	CommunityInstance,
8	ThreadAttributes,
9	UserInstance,
10	} from '@hicommonwealth/model';
11	import { NotificationCategories, ProposalType } from '@hicommonwealth/shared';
12	import { sanitizeQuillText } from 'server/util/sanitizeQuillText';
13	import { MixpanelCommunityInteractionEvent } from '../../../shared/analytics/types';
14	import { renderQuillDeltaToText } from '../../../shared/utils';
15	import {
16	createThreadMentionNotifications,
17	emitMentions,
18	parseUserMentions,
19	queryMentionedUsers,
20	uniqueMentions,
21	} from '../../util/parseUserMentions';
22	import { validateTopicGroupsMembership } from '../../util/requirementsModule/validateTopicGroupsMembership';
23	import { validateOwner } from '../../util/validateOwner';
24	import { TrackOptions } from '../server_analytics_controller';
25	import { EmitOptions } from '../server_notifications_methods/emit';
26	import { ServerThreadsController } from '../server_threads_controller';
27
28	export const Errors = {	25✔
29	InsufficientTokenBalance: 'Insufficient token balance',
30	BalanceCheckFailed: 'Could not verify user token balance',
31	ParseMentionsFailed: 'Failed to parse mentions',
32	LinkMissingTitleOrUrl: 'Links must include a title and URL',
33	UnsupportedKind: 'Only discussion and link posts supported',
34	FailedCreateThread: 'Failed to create thread',
35	DiscussionMissingTitle: 'Discussion posts must include a title',
36	NoBody: 'Thread body cannot be blank',
37	};
38
39	export type CreateThreadOptions = {
40	user: UserInstance;
41	address: AddressInstance;
42	community: CommunityInstance;
43	title: string;
44	body: string;
45	kind: string;
46	readOnly: boolean;
47	topicId?: number;
48	stage?: string;
49	url?: string;
50	canvasSignedData?: string;
51	canvasHash?: string;
52	discordMeta?: any;
53	};
54
55	export type CreateThreadResult = [
56	ThreadAttributes,
57	EmitOptions[],
58	TrackOptions,
59	];
60
61	export async function __createThread(
62	this: ServerThreadsController,
63	{
64	user,
65	address,
66	community,
67	title,
68	body,
69	kind,
70	readOnly,
71	topicId,
72	stage,
73	url,
74	canvasSignedData,
75	canvasHash,
76	discordMeta,
77	}: CreateThreadOptions,
78	): Promise<CreateThreadResult> {
79	// sanitize text
80	body = sanitizeQuillText(body);	64✔
81
82	if (kind === 'discussion') {	64!
83	if (!title \|\| !title.trim()) {	64!
UNCOV 84	throw new AppError(Errors.DiscussionMissingTitle);	×
85	}	×
86	try {	64✔
87	const quillDoc = JSON.parse(decodeURIComponent(body));	64✔
UNCOV 88	if (quillDoc.ops.length === 1 && quillDoc.ops[0].insert.trim() === '') {	×
UNCOV 89	throw new AppError(Errors.NoBody);	×
90	}	×
91	} catch (e) {
92	// check always passes if the body isn't a Quill document
93	}
94	} else if (kind === 'link') {	×
95	if (!title?.trim() \|\| !url?.trim()) {	×
96	throw new AppError(Errors.LinkMissingTitleOrUrl);	×
97	}	×
98	} else {
99	throw new AppError(Errors.UnsupportedKind);
100	}
101
102	// check if banned
103	const [canInteract, banError] = await this.banCache.checkBan({	64✔
104	communityId: community.id,
105	address: address.address,
106	});
107	if (!canInteract) {	64✔
108	throw new AppError(`Ban error: ${banError}`);	1✔
109	}	×
110
111	// Render a copy of the thread to plaintext for the search indexer
112	const plaintext = (() => {	63✔
113	try {	63✔
114	return renderQuillDeltaToText(JSON.parse(decodeURIComponent(body)));	63✔
115	} catch (e) {
116	return decodeURIComponent(body);	63✔
117	}
118	})();
119
120	// New threads get an empty version history initialized, which is passed
121	// the thread's first version, formatted on the frontend with timestamps
122	const firstVersion: any = {	63✔
123	timestamp: moment(),
124	author: address,
125	body: decodeURIComponent(body),
126	};
127	const version_history: string[] = [JSON.stringify(firstVersion)];	63✔
128
129	const threadContent: Partial<ThreadAttributes> = {	63✔
130	community_id: community.id,
131	address_id: address.id,
132	title,
133	body,
134	plaintext,
135	version_history,
136	kind,
137	stage,
138	url,
139	read_only: readOnly,
140	canvas_signed_data: canvasSignedData,
141	canvas_hash: canvasHash,
142	discord_meta: discordMeta,
143	// @ts-expect-error StrictNullChecks
144	topic_id: +topicId,
145	};
146
147	const isAdmin = await validateOwner({	63✔
148	models: this.models,
149	user,
150	// @ts-expect-error StrictNullChecks
151	communityId: community.id,
152	allowAdmin: true,
153	allowSuperAdmin: true,
154	});
155	if (!isAdmin) {	63✔
156	const { isValid, message } = await validateTopicGroupsMembership(	61✔
157	this.models,
158	// @ts-expect-error StrictNullChecks	×
159	topicId,
160	community.id,
161	address,
162	PermissionEnum.CREATE_THREAD,
163	);
164	if (!isValid) {	61!
165	throw new AppError(`${Errors.FailedCreateThread}: ${message}`);
166	}
167	}	×
168
169	const bodyText = decodeURIComponent(body);	63✔
170	const mentions = uniqueMentions(parseUserMentions(bodyText));	63✔
171	const mentionedAddresses = await queryMentionedUsers(mentions, this.models);	63✔
172
173	// begin essential database changes within transaction
174	const newThreadId = await this.models.sequelize.transaction(	63✔
175	async (transaction) => {
176	// @ts-expect-error StrictNullChecks
177	const thread = await this.models.Thread.create(threadContent, {	63✔
178	transaction,
179	});
180
181	address.last_active = new Date();	63✔
182	await address.save({ transaction });	63✔
183
184	await emitMentions(this.models, transaction, {	63✔
185	// @ts-expect-error StrictNullChecks
186	authorAddressId: address.id,
187	// @ts-expect-error StrictNullChecks
188	authorUserId: user.id,
189	authorAddress: address.address,
190	// @ts-expect-error StrictNullChecks
191	authorProfileId: address.profile_id,
192	mentions: mentionedAddresses,
193	thread,
194	});
195
196	return thread.id;	63✔
197	// end of transaction
198	},
199	);
200
201	const finalThread = await this.models.Thread.findOne({	63✔
202	where: { id: newThreadId },
203	include: [
204	{ model: this.models.Address, as: 'Address' },
205	{ model: this.models.Topic, as: 'topic' },
206	],
207	});
208
209	// exit early on error, do not emit notifications
210	if (!finalThread) {	63!
211	throw new AppError(Errors.FailedCreateThread);
212	}
213		×
214	// -----
215
216	// auto-subscribe thread creator to comments & reactions
217	await this.models.Subscription.bulkCreate([	63✔
218	{
219	// @ts-expect-error StrictNullChecks
220	subscriber_id: user.id,
221	category_id: NotificationCategories.NewComment,
222	// @ts-expect-error StrictNullChecks
223	thread_id: finalThread.id,
224	community_id: finalThread.community_id,
225	is_active: true,
226	},
227	{
228	// @ts-expect-error StrictNullChecks
229	subscriber_id: user.id,
230	category_id: NotificationCategories.NewReaction,
231	// @ts-expect-error StrictNullChecks
232	thread_id: finalThread.id,
233	community_id: finalThread.community_id,
234	is_active: true,
235	},
236	]);
237
238	const allNotificationOptions: EmitOptions[] = [];	63✔
239
240	allNotificationOptions.push(	63✔
241	...createThreadMentionNotifications(mentionedAddresses, finalThread),
242	);
243
244	allNotificationOptions.push({	63✔
245	notification: {
246	categoryId: NotificationCategories.NewThread,
247	data: {
248	created_at: new Date(),
249	// @ts-expect-error StrictNullChecks
250	thread_id: finalThread.id,
251	root_type: ProposalType.Thread,
252	root_title: finalThread.title,
253	// @ts-expect-error StrictNullChecks
254	comment_text: finalThread.body,
255	community_id: finalThread.community_id,
256	// @ts-expect-error StrictNullChecks
257	author_address: finalThread.Address.address,
258	// @ts-expect-error StrictNullChecks
259	author_community_id: finalThread.Address.community_id,
260	},
261	},
262	// @ts-expect-error StrictNullChecks
263	excludeAddresses: [finalThread.Address.address],
264	});
265
266	const analyticsOptions = {	63✔
267	event: MixpanelCommunityInteractionEvent.CREATE_THREAD,
268	community: community.id,
269	userId: user.id,
270	};
271
272	return [finalThread.toJSON(), allNotificationOptions, analyticsOptions];	63✔
273	}

hicommonwealth / commonwealth / 9604073582

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