10886892842

Committed 16 Sep 2024 03:21PM UTC coverage: 13.727% (+0.02%) from 13.711%

Build # 10886892842

Build Type

Pull #8537

github

Committed by

web-flow

Commit Message

Merge 2273def84 into 446732de2

Pull Request Pull Request #8537: Canvas v0.10 and federation readiness

Run Details

3043 of 20610 branches covered (14.76%)

Branch coverage included in aggregate %.

23 of 170 new or added lines in 34 files covered. (13.53%)

22 existing lines in 15 files now uncovered.

3975 of 30515 relevant lines covered (13.03%)

3.93 hits per line

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

60.34

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

import { AppError } from '@hicommonwealth/core';
import { AddressInstance, UserInstance } from '@hicommonwealth/model';
import { QueryTypes } from 'sequelize';
import deleteThreadFromDb from '../../util/deleteThread';
import { validateOwner } from '../../util/validateOwner';
import { ServerThreadsController } from '../server_threads_controller';

export const Errors = {
  ThreadNotFound: 'Thread not found',
  NotOwned: 'Not owned by this user',
  ContestLock: 'Cannot edit thread that is in a contest',
};

export type DeleteThreadOptions = {
  user: UserInstance;
  address: AddressInstance;
  threadId?: number;
  threadMsgId?: string;
  messageId?: string;
  canvasSignedData?: string;
  canvasMsgId?: string;
};

export type DeleteThreadResult = void;

export async function __deleteThread(
  this: ServerThreadsController,
  { user, address, threadId, threadMsgId, messageId }: DeleteThreadOptions,
): Promise<DeleteThreadResult> {
  if (!threadId) {
    // Special handling for discobot threads
    const existingThread = await this.models.Thread.findOne({
      where: {
        discord_meta: { message_id: messageId },
      },
    });
    if (existingThread) {
      threadId = existingThread.id;
    } else {
      throw new AppError(Errors.ThreadNotFound);
    }
  }

  // find thread
  const thread = await this.models.Thread.findOne({
    where: {
      id: threadId,
    },
    include: [{ model: this.models.Address, as: 'Address' }],
  });
  if (!thread) {
    throw new AppError(`${Errors.ThreadNotFound}: ${threadId}`);
  }

  // if the threadMsgId is given, validate that it is the same as the field on
  // the thread to be deleted
  if (threadMsgId && thread.canvas_msg_id !== threadMsgId) {
    throw new AppError(
      `thread.canvas_msg_id (${thread.canvas_msg_id}) !== threadMsgId (${threadMsgId})`,
    );
  }

  if (address.is_banned) throw new AppError('Banned User');

  // check ownership (bypass if admin)
  const isOwnerOrAdmin = await validateOwner({
    models: this.models,
    user,
    communityId: thread.community_id,
    entity: thread,
    allowMod: true,
    allowAdmin: true,
    allowSuperAdmin: true,
  });
  if (!isOwnerOrAdmin) {
    throw new AppError(Errors.NotOwned);
  }

  // check if thread is part of a contest topic
  const contestManagers = await this.models.sequelize.query(
    `
    SELECT cm.contest_address FROM "Threads" t
    JOIN "ContestTopics" ct on ct.topic_id = t.topic_id
    JOIN "ContestManagers" cm on cm.contest_address = ct.contest_address
    WHERE t.id = :thread_id
  `,
    {
      type: QueryTypes.SELECT,
      replacements: {
        thread_id: thread!.id,
      },
    },
  );
  if (contestManagers.length > 0) {
    throw new AppError(Errors.ContestLock);
  }

  await this.models.sequelize.transaction(async (transaction) => {
    await deleteThreadFromDb(this.models, thread, transaction);
  });

  // use callbacks so route returns and this completes in the background
  if (this.globalActivityCache) {
    // @ts-expect-error StrictNullChecks
    this.globalActivityCache.deleteActivityFromCache(thread.id);
  }
}

1	import { AppError } from '@hicommonwealth/core';
2	import { AddressInstance, UserInstance } from '@hicommonwealth/model';
3	import { QueryTypes } from 'sequelize';
4	import deleteThreadFromDb from '../../util/deleteThread';
5	import { validateOwner } from '../../util/validateOwner';
6	import { ServerThreadsController } from '../server_threads_controller';
7
8	export const Errors = {	18✔
9	ThreadNotFound: 'Thread not found',
10	NotOwned: 'Not owned by this user',
11	ContestLock: 'Cannot edit thread that is in a contest',
12	};
13
14	export type DeleteThreadOptions = {
15	user: UserInstance;
16	address: AddressInstance;
17	threadId?: number;
18	threadMsgId?: string;
19	messageId?: string;
20	canvasSignedData?: string;
21	canvasMsgId?: string;
22	};
23
24	export type DeleteThreadResult = void;
25
26	export async function __deleteThread(
27	this: ServerThreadsController,
28	{ user, address, threadId, threadMsgId, messageId }: DeleteThreadOptions,
29	): Promise<DeleteThreadResult> {
30	if (!threadId) {	3!
31	// Special handling for discobot threads
32	const existingThread = await this.models.Thread.findOne({	×
33	where: {
34	discord_meta: { message_id: messageId },
35	},
36	});
37	if (existingThread) {	×
38	threadId = existingThread.id;	×
39	} else {
40	throw new AppError(Errors.ThreadNotFound);	×
41	}
42	}
43
44	// find thread
45	const thread = await this.models.Thread.findOne({	3✔
46	where: {
47	id: threadId,
48	},
49	include: [{ model: this.models.Address, as: 'Address' }],
50	});
51	if (!thread) {	3✔
52	throw new AppError(`${Errors.ThreadNotFound}: ${threadId}`);	1✔
53	}
54
55	// if the threadMsgId is given, validate that it is the same as the field on
56	// the thread to be deleted
57	if (threadMsgId && thread.canvas_msg_id !== threadMsgId) {	2!
NEW 58	throw new AppError(	×
59	`thread.canvas_msg_id (${thread.canvas_msg_id}) !== threadMsgId (${threadMsgId})`,
60	);
61	}
62
63	if (address.is_banned) throw new AppError('Banned User');	2!
64
65	// check ownership (bypass if admin)
66	const isOwnerOrAdmin = await validateOwner({	2✔
67	models: this.models,
68	user,
69	communityId: thread.community_id,
70	entity: thread,
71	allowMod: true,
72	allowAdmin: true,
73	allowSuperAdmin: true,
74	});
75	if (!isOwnerOrAdmin) {	2✔
76	throw new AppError(Errors.NotOwned);	1✔
77	}
78
79	// check if thread is part of a contest topic
80	const contestManagers = await this.models.sequelize.query(	1✔
81	`
82	SELECT cm.contest_address FROM "Threads" t
83	JOIN "ContestTopics" ct on ct.topic_id = t.topic_id
84	JOIN "ContestManagers" cm on cm.contest_address = ct.contest_address
85	WHERE t.id = :thread_id
86	`,
87	{
88	type: QueryTypes.SELECT,
89	replacements: {
90	thread_id: thread!.id,
91	},
92	},
93	);
94	if (contestManagers.length > 0) {	1!
95	throw new AppError(Errors.ContestLock);	×
96	}
97
98	await this.models.sequelize.transaction(async (transaction) => {	1✔
99	await deleteThreadFromDb(this.models, thread, transaction);	1✔
100	});
101
102	// use callbacks so route returns and this completes in the background
103	if (this.globalActivityCache) {	1!
104	// @ts-expect-error StrictNullChecks
105	this.globalActivityCache.deleteActivityFromCache(thread.id);	×
106	}
107	}

hicommonwealth / commonwealth / 10886892842

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