10924060931

Committed 18 Sep 2024 02:17PM UTC coverage: 13.758% (-0.07%) from 13.825%

Build # 10924060931

Build Type

Pull #9256

github

Committed by

web-flow

Commit Message

Merge bfd08510d into cd47111a4

Pull Request Pull Request #9256: Refactors delete thread

Run Details

3007 of 20277 branches covered (14.83%)

Branch coverage included in aggregate %.

36 of 72 new or added lines in 19 files covered. (50.0%)

155 existing lines in 14 files now uncovered.

3940 of 30218 relevant lines covered (13.04%)

4.01 hits per line

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

0.0

/packages/commonwealth/client/scripts/views/pages/discussions/ThreadCard/ThreadOptions/AdminActions/AdminActions.tsx

import { buildUpdateThreadInput } from 'client/scripts/state/api/threads/editThread';
import { useAuthModalStore } from 'client/scripts/state/ui/modals';
import { SessionKeyError } from 'controllers/server/sessions';
import { useCommonNavigate } from 'navigation/helpers';
import React, { useState } from 'react';
import app from 'state';
import {
  useDeleteThreadMutation,
  useEditThreadMutation,
} from 'state/api/threads';
import useUserStore from 'state/ui/user';
import { PopoverMenu } from 'views/components/component_kit/CWPopoverMenu';
import { CWModal } from 'views/components/component_kit/new_designs/CWModal';
import { CWThreadAction } from 'views/components/component_kit/new_designs/cw_thread_action';
import { ArchiveThreadModal } from 'views/modals/ArchiveThreadModal';
import { ChangeThreadTopicModal } from 'views/modals/change_thread_topic_modal';
import { openConfirmation } from 'views/modals/confirmation_modal';
import { UpdateProposalStatusModal } from 'views/modals/update_proposal_status_modal';
import {
  notifyError,
  notifySuccess,
} from '../../../../../../controllers/app/notifications';
import type Thread from '../../../../../../models/Thread';
import type { IThreadCollaborator } from '../../../../../../models/Thread';
import Permissions from '../../../../../../utils/Permissions';
import { EditCollaboratorsModal } from '../../../../../modals/edit_collaborators_modal';
import './AdminActions.scss';

export type AdminActionsProps = {
  thread: Thread;
  canUpdateThread?: boolean;
  onDelete?: () => any;
  onSpamToggle?: (thread: Thread) => any;
  onLockToggle?: (isLocked: boolean) => any;
  onPinToggle?: (isPinned: boolean) => any;
  onProposalStageChange?: (newStage: string) => any;
  onSnapshotProposalFromThread?: () => any;
  onCollaboratorsEdit?: (collaborators: IThreadCollaborator[]) => any;
  onEditStart?: () => any;
  onEditConfirm?: () => any;
  onEditCancel?: () => any;
  onDownloadMarkdown?: () => void;
  hasPendingEdits?: boolean;
  editingDisabled?: boolean;
};

export const AdminActions = ({
  thread,
  onDelete,
  onSpamToggle,
  onLockToggle,
  onPinToggle,
  onProposalStageChange,
  onSnapshotProposalFromThread,
  onCollaboratorsEdit,
  onEditStart,
  onEditCancel,
  onEditConfirm,
  hasPendingEdits,
  editingDisabled,
  onDownloadMarkdown,
  canUpdateThread,
}: AdminActionsProps) => {
  const navigate = useCommonNavigate();
  const [isEditCollaboratorsModalOpen, setIsEditCollaboratorsModalOpen] =
    useState(false);
  const [isChangeTopicModalOpen, setIsChangeTopicModalOpen] = useState(false);
  const [isUpdateProposalStatusModalOpen, setIsUpdateProposalStatusModalOpen] =
    useState(false);
  const [isArchiveThreadModalOpen, setIsArchiveThreadModalOpen] =
    useState(false);

  const hasAdminPermissions =
    Permissions.isSiteAdmin() ||
    Permissions.isCommunityAdmin() ||
    Permissions.isCommunityModerator();

  const isThreadAuthor = Permissions.isThreadAuthor(thread);
  const isThreadCollaborator = Permissions.isThreadCollaborator(thread);
  const { checkForSessionKeyRevalidationErrors } = useAuthModalStore();
  const user = useUserStore();

  const { mutateAsync: deleteThread } = useDeleteThreadMutation({
    communityId: app.activeChainId() || '',
    threadId: thread.id,
    threadMsgId: thread.canvasMsgId,
    currentStage: thread.stage,
  });

  const { mutateAsync: editThread } = useEditThreadMutation({
    communityId: app.activeChainId() || '',
    threadId: thread.id,
    threadMsgId: thread.canvasMsgId,
    currentStage: thread.stage,
    currentTopicId: thread.topic?.id,
  });

  const handleDeleteThread = () => {
    openConfirmation({
      title: 'Delete Thread',
      description: <p>Delete this entire thread?</p>,
      buttons: [
        {
          label: 'Delete',
          buttonType: 'destructive',
          buttonHeight: 'sm',
          onClick: async () => {
            try {
              await deleteThread({
                thread_id: thread.id,
                canvas_signed_data: thread.canvasSignedData,
                canvas_msg_id: thread.canvasMsgId,
              });
              onDelete?.();
            } catch (err) {
              if (err instanceof SessionKeyError) {
                checkForSessionKeyRevalidationErrors(err);
                return;
              }
              console.error(err.message);
              notifyError('Failed to delete thread');
            }
          },
        },
        {
          label: 'Cancel',
          buttonType: 'primary',
          buttonHeight: 'sm',
        },
      ],
    });
  };

  const handleFlagMarkAsSpam = () => {
    openConfirmation({
      title: !thread.markedAsSpamAt
        ? 'Confirm flag as spam'
        : 'Unflag as spam?',
      description: !thread.markedAsSpamAt ? (
        <>
          <p>Are you sure you want to flag this post as spam?</p>
          <br />
          <p>
            Flagging as spam will help filter out unwanted content. Posts
            flagged as spam are hidden from the main feed and can&apos;t be
            interacted with. For transparency, spam can still be viewed by
            community members if they choose to &quot;Include posts flagged as
            spam.&quot;
          </p>
          <br />
          <p>Note that you can always unflag a post as spam.</p>
        </>
      ) : (
        <>
          <p>
            Are you sure you want to unflag this post as spam? Flagging as spam
            will help filter out unwanted content.
          </p>
          <br />
          <p>
            For transparency, spam can still be viewed by community members if
            they choose to &quot;Include posts flagged as spam.&quot;
            <br />
          </p>
        </>
      ),
      buttons: [
        {
          label: 'Cancel',
          buttonType: 'primary',
          buttonHeight: 'sm',
        },
        {
          label: !thread.markedAsSpamAt ? 'Confirm' : 'Unflag as spam?',
          buttonType: 'destructive',
          buttonHeight: 'sm',
          onClick: async () => {
            const isSpam = !thread.markedAsSpamAt;
            try {
              const input = await buildUpdateThreadInput({
                communityId: app.activeChainId() || '',
                threadId: thread.id,
                threadMsgId: thread.canvasMsgId,
                spam: isSpam,
                address: user.activeAccount?.address || '',
              });
              await editThread(input)
                .then((t: Thread | any) => onSpamToggle && onSpamToggle(t))
                .catch(() => {
                  notifyError(
                    `Could not ${!isSpam ? 'mark' : 'unmark'} thread as spam`,
                  );
                });
            } catch (err) {
              console.log(err);
            }
          },
        },
      ],
    });
  };

  const handleThreadLockToggle = async () => {
    const input = await buildUpdateThreadInput({
      address: user.activeAccount?.address || '',
      threadId: thread.id,
      threadMsgId: thread.canvasMsgId,
      readOnly: !thread.readOnly,
      communityId: app.activeChainId() || '',
    });
    editThread(input)
      .then(() => {
        notifySuccess(thread?.readOnly ? 'Unlocked!' : 'Locked!');
        onLockToggle?.(!thread?.readOnly);
      })
      .catch((e) => {
        console.log(e);
        notifyError('Could not update thread read_only');
      });
  };

  const handleThreadPinToggle = async () => {
    const input = await buildUpdateThreadInput({
      address: user.activeAccount?.address || '',
      threadId: thread.id,
      threadMsgId: thread.canvasMsgId,
      communityId: app.activeChainId() || '',
      pinned: !thread.pinned,
    });
    editThread(input)
      .then(() => {
        notifySuccess(thread?.pinned ? 'Unpinned!' : 'Pinned!');
        onPinToggle?.(!thread.pinned);
      })
      .catch(() => {
        notifyError('Could not update pinned state');
      });
  };

  const handleEditThread = async (e) => {
    e.preventDefault();
    onEditStart && onEditStart();

    if (hasPendingEdits) {
      openConfirmation({
        title: 'Info',
        description: <>Previous changes found. Restore edits?</>,
        buttons: [
          {
            label: 'Restore',
            buttonType: 'primary',
            buttonHeight: 'sm',
            onClick: onEditConfirm,
          },
          {
            label: 'Cancel',
            buttonType: 'secondary',
            buttonHeight: 'sm',
            onClick: onEditCancel,
          },
        ],
      });
      return;
    }

    onEditConfirm && onEditConfirm();
  };

  const handleSnapshotProposalClick = () => {
    const snapshotSpaces = app.chain.meta?.snapshot_spaces;
    onSnapshotProposalFromThread && onSnapshotProposalFromThread();
    navigate(
      snapshotSpaces?.length > 1
        ? '/multiple-snapshots'
        : `/snapshot/${snapshotSpaces}`,
    );
  };

  const handleArchiveThread = async () => {
    if (thread.archivedAt === null) {
      setIsArchiveThreadModalOpen(true);
    } else {
      const input = await buildUpdateThreadInput({
        threadId: thread.id,
        threadMsgId: thread.canvasMsgId,
        communityId: app.activeChainId() || '',
        archived: !thread.archivedAt,
        address: user.activeAccount?.address || '',
      });
      editThread(input)
        .then(() => {
          notifySuccess(
            `Thread has been ${
              thread?.archivedAt ? 'unarchived' : 'archived'
            }!`,
          );
        })
        .catch(() => {
          notifyError(
            `Could not ${thread?.archivedAt ? 'unarchive' : 'archive'} thread.`,
          );
        });
    }
  };

  return (
    <>
      <span
        onClick={(e) => {
          e.stopPropagation();
          e.preventDefault();
        }}
      >
        <PopoverMenu
          className="AdminActions compact"
          menuItems={[
            ...(canUpdateThread &&
            thread.archivedAt === null &&
            (hasAdminPermissions ||
              isThreadAuthor ||
              (isThreadCollaborator && !thread.readOnly))
              ? [
                  {
                    label: 'Edit',
                    disabled: editingDisabled,
                    iconLeft: 'write' as const,
                    iconLeftWeight: 'bold' as const,
                    onClick: handleEditThread,
                  },
                  {
                    label: 'Edit collaborators',
                    disabled: editingDisabled,
                    iconLeft: 'write' as const,
                    iconLeftWeight: 'bold' as const,
                    onClick: () => {
                      setIsEditCollaboratorsModalOpen(true);
                    },
                  },
                ]
              : []),
            ...(canUpdateThread && hasAdminPermissions
              ? [
                  ...(thread.archivedAt === null
                    ? [
                        {
                          onClick: handleThreadPinToggle,
                          label: thread.pinned ? 'Unpin' : 'Pin',
                          iconLeft: 'pin' as const,
                          iconLeftWeight: 'bold' as const,
                        },
                        {
                          onClick: handleThreadLockToggle,
                          label: thread.readOnly ? 'Unlock' : 'Lock',
                          iconLeft: thread.readOnly
                            ? ('keyLockOpened' as const)
                            : ('keyLockClosed' as const),
                          iconLeftWeight: 'bold' as const,
                        },
                        {
                          onClick: () => setIsChangeTopicModalOpen(true),
                          disabled: editingDisabled,
                          label: 'Change topic',
                          iconLeft: 'filter' as const,
                          iconLeftWeight: 'bold' as const,
                        },
                      ]
                    : []),
                  {
                    label: thread.archivedAt === null ? 'Archive' : 'Unarchive',
                    iconLeft:
                      thread.archivedAt === null
                        ? ('archiveTray' as const)
                        : ('archiveTrayFilled' as const),
                    iconLeftWeight: 'bold' as const,
                    onClick: handleArchiveThread,
                  },
                ]
              : []),
            ...[
              {
                onClick: () => onDownloadMarkdown?.(),
                label: 'Download as Markdown',
                iconLeft: 'download' as const,
                iconLeftWeight: 'bold' as const,
              },
            ],
            ...(canUpdateThread && (isThreadAuthor || hasAdminPermissions)
              ? [
                  ...(app.chain?.meta?.snapshot_spaces?.length
                    ? [
                        {
                          label: 'Snapshot proposal from thread',
                          iconLeft: 'democraticProposal' as const,
                          iconLeftWeight: 'bold' as const,
                          onClick: handleSnapshotProposalClick,
                        },
                      ]
                    : []),
                  ...(thread.readOnly
                    ? [
                        {
                          label: 'Snapshot proposal from thread',
                          iconLeft: 'democraticProposal' as const,
                          iconLeftWeight: 'bold' as const,
                          onClick: () => {
                            const snapshotSpaces =
                              app?.chain?.meta?.snapshot_spaces;
                            // @ts-expect-error StrictNullChecks
                            onSnapshotProposalFromThread();
                            navigate(
                              snapshotSpaces.length > 1
                                ? '/multiple-snapshots'
                                : `/snapshot/${snapshotSpaces}`,
                            );
                          },
                        },
                      ]
                    : []),
                  ...(thread.archivedAt === null
                    ? [
                        {
                          onClick: () =>
                            setIsUpdateProposalStatusModalOpen(true),
                          label: 'Update status',
                          iconLeft: 'democraticProposal' as const,
                          iconLeftWeight: 'bold' as const,
                        },
                        {
                          onClick: handleFlagMarkAsSpam,
                          label: !thread.markedAsSpamAt
                            ? 'Flag as spam'
                            : 'Unflag as spam',
                          iconLeft: 'flag' as const,
                          iconLeftWeight: 'bold' as const,
                        },
                      ]
                    : []),
                  {
                    onClick: handleDeleteThread,
                    label: 'Delete',
                    disabled: editingDisabled,
                    iconLeft: 'trash' as const,
                    iconLeftWeight: 'bold' as const,
                    className: 'danger',
                  },
                ]
              : []),
          ]}
          renderTrigger={(onClick) => (
            <CWThreadAction action="overflow" onClick={onClick} />
          )}
        />
      </span>

      <CWModal
        size="small"
        visibleOverflow
        content={
          <ChangeThreadTopicModal
            thread={thread}
            onModalClose={() => setIsChangeTopicModalOpen(false)}
          />
        }
        onClose={() => setIsChangeTopicModalOpen(false)}
        open={isChangeTopicModalOpen}
      />

      <CWModal
        size="medium"
        visibleOverflow
        content={
          <UpdateProposalStatusModal
            onChangeHandler={(s) =>
              onProposalStageChange && onProposalStageChange(s)
            }
            thread={thread}
            onModalClose={() => setIsUpdateProposalStatusModalOpen(false)}
          />
        }
        onClose={() => setIsUpdateProposalStatusModalOpen(false)}
        open={isUpdateProposalStatusModalOpen}
      />

      <CWModal
        size="small"
        content={
          <EditCollaboratorsModal
            onModalClose={() => setIsEditCollaboratorsModalOpen(false)}
            thread={thread}
            // @ts-expect-error StrictNullChecks
            onCollaboratorsUpdated={onCollaboratorsEdit}
          />
        }
        onClose={() => setIsEditCollaboratorsModalOpen(false)}
        open={isEditCollaboratorsModalOpen}
      />

      <CWModal
        content={
          <ArchiveThreadModal
            thread={thread}
            onModalClose={() => setIsArchiveThreadModalOpen(false)}
          />
        }
        onClose={() => setIsArchiveThreadModalOpen(false)}
        open={isArchiveThreadModalOpen}
      />
    </>
  );
};

1	import { buildUpdateThreadInput } from 'client/scripts/state/api/threads/editThread';
2	import { useAuthModalStore } from 'client/scripts/state/ui/modals';
3	import { SessionKeyError } from 'controllers/server/sessions';
4	import { useCommonNavigate } from 'navigation/helpers';
5	import React, { useState } from 'react';
6	import app from 'state';
7	import {
8	useDeleteThreadMutation,
9	useEditThreadMutation,
10	} from 'state/api/threads';
11	import useUserStore from 'state/ui/user';
12	import { PopoverMenu } from 'views/components/component_kit/CWPopoverMenu';
13	import { CWModal } from 'views/components/component_kit/new_designs/CWModal';
14	import { CWThreadAction } from 'views/components/component_kit/new_designs/cw_thread_action';
15	import { ArchiveThreadModal } from 'views/modals/ArchiveThreadModal';
16	import { ChangeThreadTopicModal } from 'views/modals/change_thread_topic_modal';
17	import { openConfirmation } from 'views/modals/confirmation_modal';
18	import { UpdateProposalStatusModal } from 'views/modals/update_proposal_status_modal';
19	import {
20	notifyError,
21	notifySuccess,
22	} from '../../../../../../controllers/app/notifications';
23	import type Thread from '../../../../../../models/Thread';
24	import type { IThreadCollaborator } from '../../../../../../models/Thread';
25	import Permissions from '../../../../../../utils/Permissions';
26	import { EditCollaboratorsModal } from '../../../../../modals/edit_collaborators_modal';
27	import './AdminActions.scss';
28
29	export type AdminActionsProps = {
30	thread: Thread;
31	canUpdateThread?: boolean;
32	onDelete?: () => any;
33	onSpamToggle?: (thread: Thread) => any;
34	onLockToggle?: (isLocked: boolean) => any;
35	onPinToggle?: (isPinned: boolean) => any;
36	onProposalStageChange?: (newStage: string) => any;
37	onSnapshotProposalFromThread?: () => any;
38	onCollaboratorsEdit?: (collaborators: IThreadCollaborator[]) => any;
39	onEditStart?: () => any;
40	onEditConfirm?: () => any;
41	onEditCancel?: () => any;
42	onDownloadMarkdown?: () => void;
43	hasPendingEdits?: boolean;
44	editingDisabled?: boolean;
45	};
46
47	export const AdminActions = ({	×
48	thread,
49	onDelete,
50	onSpamToggle,
51	onLockToggle,
52	onPinToggle,
53	onProposalStageChange,
54	onSnapshotProposalFromThread,
55	onCollaboratorsEdit,
56	onEditStart,
57	onEditCancel,
58	onEditConfirm,
59	hasPendingEdits,
60	editingDisabled,
61	onDownloadMarkdown,
62	canUpdateThread,
63	}: AdminActionsProps) => {
64	const navigate = useCommonNavigate();	×
65	const [isEditCollaboratorsModalOpen, setIsEditCollaboratorsModalOpen] =
66	useState(false);	×
67	const [isChangeTopicModalOpen, setIsChangeTopicModalOpen] = useState(false);	×
68	const [isUpdateProposalStatusModalOpen, setIsUpdateProposalStatusModalOpen] =
69	useState(false);	×
70	const [isArchiveThreadModalOpen, setIsArchiveThreadModalOpen] =
71	useState(false);	×
72
73	const hasAdminPermissions =
74	Permissions.isSiteAdmin() \|\|	×
75	Permissions.isCommunityAdmin() \|\|
76	Permissions.isCommunityModerator();
77
78	const isThreadAuthor = Permissions.isThreadAuthor(thread);	×
79	const isThreadCollaborator = Permissions.isThreadCollaborator(thread);	×
80	const { checkForSessionKeyRevalidationErrors } = useAuthModalStore();	×
81	const user = useUserStore();	×
82
83	const { mutateAsync: deleteThread } = useDeleteThreadMutation({	×
84	communityId: app.activeChainId() \|\| '',	×
85	threadId: thread.id,
86	threadMsgId: thread.canvasMsgId,
87	currentStage: thread.stage,
88	});
89
90	const { mutateAsync: editThread } = useEditThreadMutation({	×
91	communityId: app.activeChainId() \|\| '',	×
92	threadId: thread.id,
93	threadMsgId: thread.canvasMsgId,
94	currentStage: thread.stage,
95	currentTopicId: thread.topic?.id,
96	});
97
98	const handleDeleteThread = () => {	×
99	openConfirmation({	×
100	title: 'Delete Thread',
101	description: <p>Delete this entire thread?</p>,
102	buttons: [
103	{
104	label: 'Delete',
105	buttonType: 'destructive',
106	buttonHeight: 'sm',
107	onClick: async () => {
108	try {	×
109	await deleteThread({	×
110	thread_id: thread.id,
111	canvas_signed_data: thread.canvasSignedData,
112	canvas_msg_id: thread.canvasMsgId,
113	});
114	onDelete?.();	×
115	} catch (err) {
116	if (err instanceof SessionKeyError) {	×
117	checkForSessionKeyRevalidationErrors(err);	×
118	return;	×
119	}
NEW 120	console.error(err.message);	×
121	notifyError('Failed to delete thread');	×
122	}
123	},
124	},
125	{
126	label: 'Cancel',
127	buttonType: 'primary',
128	buttonHeight: 'sm',
129	},
130	],
131	});
132	};
133
134	const handleFlagMarkAsSpam = () => {	×
135	openConfirmation({	×
136	title: !thread.markedAsSpamAt	×
137	? 'Confirm flag as spam'
138	: 'Unflag as spam?',
139	description: !thread.markedAsSpamAt ? (	×
140	<>
141	<p>Are you sure you want to flag this post as spam?</p>
142	<br />
143	<p>
144	Flagging as spam will help filter out unwanted content. Posts
145	flagged as spam are hidden from the main feed and can't be
146	interacted with. For transparency, spam can still be viewed by
147	community members if they choose to "Include posts flagged as
148	spam."
149	</p>
150	<br />
151	<p>Note that you can always unflag a post as spam.</p>
152	</>
153	) : (
154	<>
155	<p>
156	Are you sure you want to unflag this post as spam? Flagging as spam
157	will help filter out unwanted content.
158	</p>
159	<br />
160	<p>
161	For transparency, spam can still be viewed by community members if
162	they choose to "Include posts flagged as spam."
163	<br />
164	</p>
165	</>
166	),
167	buttons: [
168	{
169	label: 'Cancel',
170	buttonType: 'primary',
171	buttonHeight: 'sm',
172	},
173	{
174	label: !thread.markedAsSpamAt ? 'Confirm' : 'Unflag as spam?',	×
175	buttonType: 'destructive',
176	buttonHeight: 'sm',
177	onClick: async () => {
178	const isSpam = !thread.markedAsSpamAt;	×
179	try {	×
180	const input = await buildUpdateThreadInput({	×
181	communityId: app.activeChainId() \|\| '',	×
182	threadId: thread.id,
183	threadMsgId: thread.canvasMsgId,
184	spam: isSpam,
185	address: user.activeAccount?.address \|\| '',	×
186	});
187	await editThread(input)	×
188	.then((t: Thread \| any) => onSpamToggle && onSpamToggle(t))	×
189	.catch(() => {
190	notifyError(	×
191	`Could not ${!isSpam ? 'mark' : 'unmark'} thread as spam`,	×
192	);
193	});
194	} catch (err) {
195	console.log(err);	×
196	}
197	},
198	},
199	],
200	});
201	};
202
203	const handleThreadLockToggle = async () => {	×
204	const input = await buildUpdateThreadInput({	×
205	address: user.activeAccount?.address \|\| '',	×
206	threadId: thread.id,
207	threadMsgId: thread.canvasMsgId,
208	readOnly: !thread.readOnly,
209	communityId: app.activeChainId() \|\| '',	×
210	});
211	editThread(input)	×
212	.then(() => {
213	notifySuccess(thread?.readOnly ? 'Unlocked!' : 'Locked!');	×
214	onLockToggle?.(!thread?.readOnly);	×
215	})
216	.catch((e) => {
217	console.log(e);	×
218	notifyError('Could not update thread read_only');	×
219	});
220	};
221
222	const handleThreadPinToggle = async () => {	×
223	const input = await buildUpdateThreadInput({	×
224	address: user.activeAccount?.address \|\| '',	×
225	threadId: thread.id,
226	threadMsgId: thread.canvasMsgId,
227	communityId: app.activeChainId() \|\| '',	×
228	pinned: !thread.pinned,
229	});
230	editThread(input)	×
231	.then(() => {
232	notifySuccess(thread?.pinned ? 'Unpinned!' : 'Pinned!');	×
233	onPinToggle?.(!thread.pinned);	×
234	})
235	.catch(() => {
236	notifyError('Could not update pinned state');	×
237	});
238	};
239
240	const handleEditThread = async (e) => {	×
241	e.preventDefault();	×
242	onEditStart && onEditStart();	×
243
244	if (hasPendingEdits) {	×
245	openConfirmation({	×
246	title: 'Info',
247	description: <>Previous changes found. Restore edits?</>,
248	buttons: [
249	{
250	label: 'Restore',
251	buttonType: 'primary',
252	buttonHeight: 'sm',
253	onClick: onEditConfirm,
254	},
255	{
256	label: 'Cancel',
257	buttonType: 'secondary',
258	buttonHeight: 'sm',
259	onClick: onEditCancel,
260	},
261	],
262	});
263	return;	×
264	}
265
266	onEditConfirm && onEditConfirm();	×
267	};
268
269	const handleSnapshotProposalClick = () => {	×
270	const snapshotSpaces = app.chain.meta?.snapshot_spaces;	×
271	onSnapshotProposalFromThread && onSnapshotProposalFromThread();	×
272	navigate(	×
273	snapshotSpaces?.length > 1	×
274	? '/multiple-snapshots'
275	: `/snapshot/${snapshotSpaces}`,
276	);
277	};
278
279	const handleArchiveThread = async () => {	×
280	if (thread.archivedAt === null) {	×
281	setIsArchiveThreadModalOpen(true);	×
282	} else {
283	const input = await buildUpdateThreadInput({	×
284	threadId: thread.id,
285	threadMsgId: thread.canvasMsgId,
286	communityId: app.activeChainId() \|\| '',	×
287	archived: !thread.archivedAt,
288	address: user.activeAccount?.address \|\| '',	×
289	});
290	editThread(input)	×
291	.then(() => {
292	notifySuccess(	×
293	`Thread has been ${
294	thread?.archivedAt ? 'unarchived' : 'archived'	×
295	}!`,
296	);
297	})
298	.catch(() => {
299	notifyError(	×
300	`Could not ${thread?.archivedAt ? 'unarchive' : 'archive'} thread.`,	×
301	);
302	});
303	}
304	};
305
306	return (	×
307	<>
308	<span
309	onClick={(e) => {
310	e.stopPropagation();	×
311	e.preventDefault();	×
312	}}
313	>
314	<PopoverMenu
315	className="AdminActions compact"
316	menuItems={[
317	...(canUpdateThread &&	×
318	thread.archivedAt === null &&
319	(hasAdminPermissions \|\|
320	isThreadAuthor \|\|
321	(isThreadCollaborator && !thread.readOnly))
322	? [
323	{
324	label: 'Edit',
325	disabled: editingDisabled,
326	iconLeft: 'write' as const,
327	iconLeftWeight: 'bold' as const,
328	onClick: handleEditThread,
329	},
330	{
331	label: 'Edit collaborators',
332	disabled: editingDisabled,
333	iconLeft: 'write' as const,
334	iconLeftWeight: 'bold' as const,
335	onClick: () => {
336	setIsEditCollaboratorsModalOpen(true);	×
337	},
338	},
339	]
340	: []),
341	...(canUpdateThread && hasAdminPermissions	×
342	? [
343	...(thread.archivedAt === null	×
344	? [
345	{
346	onClick: handleThreadPinToggle,
347	label: thread.pinned ? 'Unpin' : 'Pin',	×
348	iconLeft: 'pin' as const,
349	iconLeftWeight: 'bold' as const,
350	},
351	{
352	onClick: handleThreadLockToggle,
353	label: thread.readOnly ? 'Unlock' : 'Lock',	×
354	iconLeft: thread.readOnly	×
355	? ('keyLockOpened' as const)
356	: ('keyLockClosed' as const),
357	iconLeftWeight: 'bold' as const,
358	},
359	{
360	onClick: () => setIsChangeTopicModalOpen(true),	×
361	disabled: editingDisabled,
362	label: 'Change topic',
363	iconLeft: 'filter' as const,
364	iconLeftWeight: 'bold' as const,
365	},
366	]
367	: []),
368	{
369	label: thread.archivedAt === null ? 'Archive' : 'Unarchive',	×
370	iconLeft:
371	thread.archivedAt === null	×
372	? ('archiveTray' as const)
373	: ('archiveTrayFilled' as const),
374	iconLeftWeight: 'bold' as const,
375	onClick: handleArchiveThread,
376	},
377	]
378	: []),
379	...[
380	{
381	onClick: () => onDownloadMarkdown?.(),	×
382	label: 'Download as Markdown',
383	iconLeft: 'download' as const,
384	iconLeftWeight: 'bold' as const,
385	},
386	],
387	...(canUpdateThread && (isThreadAuthor \|\| hasAdminPermissions)	×
388	? [
389	...(app.chain?.meta?.snapshot_spaces?.length	×
390	? [
391	{
392	label: 'Snapshot proposal from thread',
393	iconLeft: 'democraticProposal' as const,
394	iconLeftWeight: 'bold' as const,
395	onClick: handleSnapshotProposalClick,
396	},
397	]
398	: []),
399	...(thread.readOnly	×
400	? [
401	{
402	label: 'Snapshot proposal from thread',
403	iconLeft: 'democraticProposal' as const,
404	iconLeftWeight: 'bold' as const,
405	onClick: () => {
406	const snapshotSpaces =
407	app?.chain?.meta?.snapshot_spaces;	×
408	// @ts-expect-error StrictNullChecks
409	onSnapshotProposalFromThread();	×
410	navigate(	×
411	snapshotSpaces.length > 1	×
412	? '/multiple-snapshots'
413	: `/snapshot/${snapshotSpaces}`,
414	);
415	},
416	},
417	]
418	: []),
419	...(thread.archivedAt === null	×
420	? [
421	{
422	onClick: () =>
423	setIsUpdateProposalStatusModalOpen(true),	×
424	label: 'Update status',
425	iconLeft: 'democraticProposal' as const,
426	iconLeftWeight: 'bold' as const,
427	},
428	{
429	onClick: handleFlagMarkAsSpam,
430	label: !thread.markedAsSpamAt	×
431	? 'Flag as spam'
432	: 'Unflag as spam',
433	iconLeft: 'flag' as const,
434	iconLeftWeight: 'bold' as const,
435	},
436	]
437	: []),
438	{
439	onClick: handleDeleteThread,
440	label: 'Delete',
441	disabled: editingDisabled,
442	iconLeft: 'trash' as const,
443	iconLeftWeight: 'bold' as const,
444	className: 'danger',
445	},
446	]
447	: []),
448	]}
449	renderTrigger={(onClick) => (
450	<CWThreadAction action="overflow" onClick={onClick} />	×
451	)}
452	/>
453	</span>
454
455	<CWModal
456	size="small"
457	visibleOverflow
458	content={
459	<ChangeThreadTopicModal
460	thread={thread}
461	onModalClose={() => setIsChangeTopicModalOpen(false)}	×
462	/>
463	}
464	onClose={() => setIsChangeTopicModalOpen(false)}	×
465	open={isChangeTopicModalOpen}
466	/>
467
468	<CWModal
469	size="medium"
470	visibleOverflow
471	content={
472	<UpdateProposalStatusModal
473	onChangeHandler={(s) =>
474	onProposalStageChange && onProposalStageChange(s)	×
475	}
476	thread={thread}
477	onModalClose={() => setIsUpdateProposalStatusModalOpen(false)}	×
478	/>
479	}
480	onClose={() => setIsUpdateProposalStatusModalOpen(false)}	×
481	open={isUpdateProposalStatusModalOpen}
482	/>
483
484	<CWModal
485	size="small"
486	content={
487	<EditCollaboratorsModal
488	onModalClose={() => setIsEditCollaboratorsModalOpen(false)}	×
489	thread={thread}
490	// @ts-expect-error StrictNullChecks
491	onCollaboratorsUpdated={onCollaboratorsEdit}
492	/>
493	}
494	onClose={() => setIsEditCollaboratorsModalOpen(false)}	×
495	open={isEditCollaboratorsModalOpen}
496	/>
497
498	<CWModal
499	content={
500	<ArchiveThreadModal
501	thread={thread}
502	onModalClose={() => setIsArchiveThreadModalOpen(false)}	×
503	/>
504	}
505	onClose={() => setIsArchiveThreadModalOpen(false)}	×
506	open={isArchiveThreadModalOpen}
507	/>
508	</>
509	);
510	};

hicommonwealth / commonwealth / 10924060931

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