10252209808

Committed 05 Aug 2024 04:05PM UTC coverage: 15.719% (+0.001%) from 15.718%

Build # 10252209808

Build Type

Pull #8737

github

Committed by

web-flow

Commit Message

Merge c0049d997 into e0d9dd7a8

Pull Request Pull Request #8737: Fixed upgrade roles form to display all addresses

Run Details

3533 of 21024 branches covered (16.8%)

Branch coverage included in aggregate %.

0 of 11 new or added lines in 1 file covered. (0.0%)

5 existing lines in 2 files now uncovered.

4694 of 31315 relevant lines covered (14.99%)

4.99 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/helpers.ts

import { NotificationCategories } from '@hicommonwealth/shared';
import { notifySuccess } from 'controllers/app/notifications';
import moment from 'moment';
import { Dispatch, SetStateAction } from 'react';
import app from 'state';
import { PopoverMenuItem } from 'views/components/component_kit/CWPopoverMenu';
import type NotificationSubscription from '../../../models/NotificationSubscription';
import type Thread from '../../../models/Thread';
import { ThreadFeaturedFilterTypes } from '../../../models/types';

export const getLastUpdated = (thread: Thread) => {
  if (!thread) return;

  const { lastCommentedOn } = thread;
  const lastComment = lastCommentedOn ? Number(lastCommentedOn.utc()) : 0;
  const createdAt = Number(thread.createdAt.utc());
  const lastUpdate = Math.max(createdAt, lastComment);
  return moment(lastUpdate);
};

export const isHot = (thread: Thread) => {
  return (
    moment.duration(moment().diff(getLastUpdated(thread))).asSeconds() <
    24 * 60 * 60
  );
};

export const isNewThread = (threadCreatedAt: moment.Moment) => {
  const diffInMs = moment().diff(threadCreatedAt);
  return moment.duration(diffInMs).asHours() < 48;
};

export const getLastUpdate = (thread: Thread): number => {
  if (!thread) return 0;
  const lastComment = thread.lastCommentedOn?.unix() || 0;
  const createdAt = thread.createdAt?.unix() || 0;
  const lastUpdate = Math.max(createdAt, lastComment);
  return lastUpdate;
};

export const onFeaturedDiscussionPage = (p, topic) =>
  decodeURI(p).endsWith(`/discussions/${topic}`);

export const orderDiscussionsbyLastComment = (a, b) => {
  const tsB = Math.max(+b.createdAt, +(b.lastCommentedOn || 0));
  const tsA = Math.max(+a.createdAt, +(a.lastCommentedOn || 0));
  return tsB - tsA;
};

export const handleToggleSubscription = async (
  thread: Thread,
  commentSubscription: NotificationSubscription,
  reactionSubscription: NotificationSubscription,
  isSubscribed: boolean,
  setIsSubscribed?: Dispatch<SetStateAction<boolean>>,
) => {
  if (!commentSubscription || !reactionSubscription) {
    await Promise.all([
      app.user.notifications.subscribe({
        categoryId: NotificationCategories.NewReaction,
        options: {
          threadId: thread.id,
        },
      }),
      app.user.notifications.subscribe({
        categoryId: NotificationCategories.NewComment,
        options: {
          threadId: thread.id,
        },
      }),
    ]);
    notifySuccess('Subscribed!');
  } else if (isSubscribed) {
    await app.user.notifications.disableSubscriptions([
      commentSubscription,
      reactionSubscription,
    ]);
    notifySuccess('Unsubscribed!');
  } else {
    await app.user.notifications.enableSubscriptions([
      commentSubscription,
      reactionSubscription,
    ]);
    notifySuccess('Subscribed!');
  }
  if (setIsSubscribed) setIsSubscribed(!isSubscribed);
};

export const getCommentSubscription = (thread: Thread) => {
  return app.user.notifications.findNotificationSubscription({
    categoryId: NotificationCategories.NewComment,
    options: { threadId: thread.id },
  });
};

export const getReactionSubscription = (thread: Thread) => {
  return app.user.notifications.findNotificationSubscription({
    categoryId: NotificationCategories.NewReaction,
    options: { threadId: thread.id },
  });
};

export const getThreadSubScriptionMenuItem = (
  thread: Thread,
  setIsSubscribed: Dispatch<SetStateAction<boolean>>,
  archivedAt: moment.Moment | null,
): PopoverMenuItem => {
  const commentSubscription = getCommentSubscription(thread);
  const reactionSubscription = getReactionSubscription(thread);

  const isSubscribed =
    commentSubscription?.isActive && reactionSubscription?.isActive;

  return {
    onClick: () => {
      handleToggleSubscription(
        thread,
        getCommentSubscription(thread),
        getReactionSubscription(thread),
        isSubscribed,
        setIsSubscribed,
      );
    },
    label: isSubscribed ? 'Unsubscribe' : 'Subscribe',
    iconLeft: isSubscribed ? 'unsubscribe' : 'bell',
    disabled: archivedAt ? true : false,
  };
};

/**
 * This function is responsible for sorting threads in state. Maybe the user pins a
 * thread, this thread is still in a lower position in the state object/arrary. This
 * function will sort those correctly.
 */
export const sortPinned = (t: Thread[]) => {
  return [...t].sort((a, b) => {
    if (a.pinned === b.pinned) return 0; // return 0 when they are equal
    return a.pinned ? -1 : 1; // sort based on the pinned status
  });
};

/**
 * This function is responsible for sorting threads in state that were earlier
 * sorted by another featured flag
 */
export const sortByFeaturedFilter = (t: Thread[], featuredFilter) => {
  if (featuredFilter === ThreadFeaturedFilterTypes.Oldest) {
    return [...t].sort((a, b) => moment(a.createdAt).diff(moment(b.createdAt)));
  }

  if (featuredFilter === ThreadFeaturedFilterTypes.MostComments) {
    return [...t].sort((a, b) => b.numberOfComments - a.numberOfComments);
  }

  if (featuredFilter === ThreadFeaturedFilterTypes.MostLikes) {
    return [...t].sort((a, b) => b.reactionWeightsSum - a.reactionWeightsSum);
  }

  if (featuredFilter === ThreadFeaturedFilterTypes.LatestActivity) {
    return [...t].sort((a, b) =>
      moment(b.latestActivity).diff(moment(a.latestActivity)),
    );
  }

  // Default: Assuming featuredFilter === 'newest'
  return [...t].sort((a, b) => moment(b.createdAt).diff(moment(a.createdAt)));
};

1	import { NotificationCategories } from '@hicommonwealth/shared';
2	import { notifySuccess } from 'controllers/app/notifications';
3	import moment from 'moment';
4	import { Dispatch, SetStateAction } from 'react';
5	import app from 'state';
6	import { PopoverMenuItem } from 'views/components/component_kit/CWPopoverMenu';
7	import type NotificationSubscription from '../../../models/NotificationSubscription';
8	import type Thread from '../../../models/Thread';
9	import { ThreadFeaturedFilterTypes } from '../../../models/types';
10
11	export const getLastUpdated = (thread: Thread) => {	×
12	if (!thread) return;	×
13
14	const { lastCommentedOn } = thread;	×
15	const lastComment = lastCommentedOn ? Number(lastCommentedOn.utc()) : 0;	×
16	const createdAt = Number(thread.createdAt.utc());	×
17	const lastUpdate = Math.max(createdAt, lastComment);	×
18	return moment(lastUpdate);	×
19	};
20
21	export const isHot = (thread: Thread) => {	×
22	return (	×
23	moment.duration(moment().diff(getLastUpdated(thread))).asSeconds() <
24	24 * 60 * 60
25	);
26	};
27
28	export const isNewThread = (threadCreatedAt: moment.Moment) => {	×
29	const diffInMs = moment().diff(threadCreatedAt);	×
30	return moment.duration(diffInMs).asHours() < 48;	×
31	};
32
33	export const getLastUpdate = (thread: Thread): number => {	×
34	if (!thread) return 0;	×
35	const lastComment = thread.lastCommentedOn?.unix() \|\| 0;	×
36	const createdAt = thread.createdAt?.unix() \|\| 0;	×
37	const lastUpdate = Math.max(createdAt, lastComment);	×
38	return lastUpdate;	×
39	};
40
41	export const onFeaturedDiscussionPage = (p, topic) =>	×
42	decodeURI(p).endsWith(`/discussions/${topic}`);	×
43
44	export const orderDiscussionsbyLastComment = (a, b) => {	×
45	const tsB = Math.max(+b.createdAt, +(b.lastCommentedOn \|\| 0));	×
46	const tsA = Math.max(+a.createdAt, +(a.lastCommentedOn \|\| 0));	×
47	return tsB - tsA;	×
48	};
49
50	export const handleToggleSubscription = async (	×
51	thread: Thread,
52	commentSubscription: NotificationSubscription,
53	reactionSubscription: NotificationSubscription,
54	isSubscribed: boolean,
55	setIsSubscribed?: Dispatch<SetStateAction<boolean>>,
56	) => {
57	if (!commentSubscription \|\| !reactionSubscription) {	×
58	await Promise.all([	×
59	app.user.notifications.subscribe({
60	categoryId: NotificationCategories.NewReaction,
61	options: {
62	threadId: thread.id,
63	},
64	}),
65	app.user.notifications.subscribe({
66	categoryId: NotificationCategories.NewComment,
67	options: {
68	threadId: thread.id,
69	},
70	}),
71	]);
72	notifySuccess('Subscribed!');	×
73	} else if (isSubscribed) {	×
74	await app.user.notifications.disableSubscriptions([	×
75	commentSubscription,
76	reactionSubscription,
77	]);
78	notifySuccess('Unsubscribed!');	×
79	} else {
80	await app.user.notifications.enableSubscriptions([	×
81	commentSubscription,
82	reactionSubscription,
83	]);
84	notifySuccess('Subscribed!');	×
85	}
86	if (setIsSubscribed) setIsSubscribed(!isSubscribed);	×
87	};
88
89	export const getCommentSubscription = (thread: Thread) => {	×
90	return app.user.notifications.findNotificationSubscription({	×
91	categoryId: NotificationCategories.NewComment,
92	options: { threadId: thread.id },
93	});
94	};
95
96	export const getReactionSubscription = (thread: Thread) => {	×
97	return app.user.notifications.findNotificationSubscription({	×
98	categoryId: NotificationCategories.NewReaction,
99	options: { threadId: thread.id },
100	});
101	};
102
103	export const getThreadSubScriptionMenuItem = (	×
104	thread: Thread,
105	setIsSubscribed: Dispatch<SetStateAction<boolean>>,
106	archivedAt: moment.Moment \| null,
107	): PopoverMenuItem => {
108	const commentSubscription = getCommentSubscription(thread);	×
109	const reactionSubscription = getReactionSubscription(thread);	×
110
111	const isSubscribed =
112	commentSubscription?.isActive && reactionSubscription?.isActive;	×
113
114	return {	×
115	onClick: () => {
116	handleToggleSubscription(	×
117	thread,
118	getCommentSubscription(thread),
119	getReactionSubscription(thread),
120	isSubscribed,
121	setIsSubscribed,
122	);
123	},
124	label: isSubscribed ? 'Unsubscribe' : 'Subscribe',	×
125	iconLeft: isSubscribed ? 'unsubscribe' : 'bell',	×
126	disabled: archivedAt ? true : false,	×
127	};
128	};
129
130	/**
131	* This function is responsible for sorting threads in state. Maybe the user pins a
132	* thread, this thread is still in a lower position in the state object/arrary. This
133	* function will sort those correctly.
134	*/
135	export const sortPinned = (t: Thread[]) => {	×
136	return [...t].sort((a, b) => {	×
137	if (a.pinned === b.pinned) return 0; // return 0 when they are equal	×
138	return a.pinned ? -1 : 1; // sort based on the pinned status	×
139	});
140	};
141
142	/**
143	* This function is responsible for sorting threads in state that were earlier
144	* sorted by another featured flag
145	*/
146	export const sortByFeaturedFilter = (t: Thread[], featuredFilter) => {	×
147	if (featuredFilter === ThreadFeaturedFilterTypes.Oldest) {	×
148	return [...t].sort((a, b) => moment(a.createdAt).diff(moment(b.createdAt)));	×
149	}
150
151	if (featuredFilter === ThreadFeaturedFilterTypes.MostComments) {	×
152	return [...t].sort((a, b) => b.numberOfComments - a.numberOfComments);	×
153	}
154
155	if (featuredFilter === ThreadFeaturedFilterTypes.MostLikes) {	×
156	return [...t].sort((a, b) => b.reactionWeightsSum - a.reactionWeightsSum);	×
157	}
158
UNCOV 159	if (featuredFilter === ThreadFeaturedFilterTypes.LatestActivity) {	×
UNCOV 160	return [...t].sort((a, b) =>	×
161	moment(b.latestActivity).diff(moment(a.latestActivity)),	×
162	);
163	}
164
165	// Default: Assuming featuredFilter === 'newest'
UNCOV 166	return [...t].sort((a, b) => moment(b.createdAt).diff(moment(a.createdAt)));	×
167	};

hicommonwealth / commonwealth / 10252209808

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