8917566083

Committed 02 May 2024 02:03AM UTC coverage: 95.0% (-0.3%) from 95.349%

Build # 8917566083

Build Type

Pull #1078

github

Committed by

web-flow

Commit Message

Merge 57a7e885d into a3496979b

Pull Request Pull Request #1078: feat: add pr review icons (approved, requested changes, commented, dismissed)

Run Details

379 of 399 branches covered (94.99%)

Branch coverage included in aggregate %.

29 of 31 new or added lines in 6 files covered. (93.55%)

9 existing lines in 4 files now uncovered.

970 of 1021 relevant lines covered (95.0%)

19.07 hits per line

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

93.52

/src/hooks/useNotifications.ts

import type { AxiosError } from 'axios';
import { useCallback, useState } from 'react';

import type {
  AccountNotifications,
  AuthState,
  GitifyError,
  SettingsState,
  Status,
} from '../types';
import type { GitHubRESTError, Notification } from '../typesGitHub';
import {
  ignoreNotificationThreadSubscription,
  listNotificationsForAuthenticatedUser,
  markNotificationThreadAsDone,
  markNotificationThreadAsRead,
  markRepositoryNotificationsAsRead,
} from '../utils/api/client';
import { determineFailureType } from '../utils/api/errors';
import Constants from '../utils/constants';
import { getTokenForHost, isGitHubLoggedIn } from '../utils/helpers';
import {
  setTrayIconColor,
  triggerNativeNotifications,
} from '../utils/notifications';
import { removeNotification } from '../utils/remove-notification';
import { removeNotifications } from '../utils/remove-notifications';
import { getGitifySubjectDetails } from '../utils/subject';

interface NotificationsState {
  notifications: AccountNotifications[];
  removeNotificationFromState: (id: string, hostname: string) => void;
  fetchNotifications: (
    accounts: AuthState,
    settings: SettingsState,
  ) => Promise<void>;
  markNotificationRead: (
    accounts: AuthState,
    id: string,
    hostname: string,
  ) => Promise<void>;
  markNotificationDone: (
    accounts: AuthState,
    id: string,
    hostname: string,
  ) => Promise<void>;
  unsubscribeNotification: (
    accounts: AuthState,
    id: string,
    hostname: string,
  ) => Promise<void>;
  markRepoNotifications: (
    accounts: AuthState,
    repoSlug: string,
    hostname: string,
  ) => Promise<void>;
  markRepoNotificationsDone: (
    accounts: AuthState,
    repoSlug: string,
    hostname: string,
  ) => Promise<void>;
  status: Status;
  errorDetails: GitifyError;
}

export const useNotifications = (): NotificationsState => {
  const [status, setStatus] = useState<Status>('success');
  const [errorDetails, setErrorDetails] = useState<GitifyError>();

  const [notifications, setNotifications] = useState<AccountNotifications[]>(
    [],
  );

  const fetchNotifications = useCallback(
    async (accounts: AuthState, settings: SettingsState) => {
      function getGitHubNotifications() {
        if (!isGitHubLoggedIn(accounts)) {
          return;
        }

        return listNotificationsForAuthenticatedUser(
          Constants.DEFAULT_AUTH_OPTIONS.hostname,
          accounts.token,
          settings,
        );
      }

      function getEnterpriseNotifications() {
        return accounts.enterpriseAccounts.map((account) => {
          return listNotificationsForAuthenticatedUser(
            account.hostname,
            account.token,
            settings,
          );
        });
      }

      setStatus('loading');

      return Promise.all([
        getGitHubNotifications(),
        ...getEnterpriseNotifications(),
      ])
        .then(([...responses]) => {
          const accountsNotifications: AccountNotifications[] = responses
            .filter((response) => !!response)
            .map((accountNotifications) => {
              const { hostname } = new URL(accountNotifications.config.url);
              return {
                hostname,
                notifications: accountNotifications.data.map(
                  (notification: Notification) => ({
                    ...notification,
                    hostname,
                  }),
                ),
              };
            });

          Promise.all(
            accountsNotifications.map(async (accountNotifications) => {
              return {
                hostname: accountNotifications.hostname,
                notifications: await Promise.all<Notification>(
                  accountNotifications.notifications.map(
                    async (notification: Notification) => {
                      if (!settings.detailedNotifications) {
                        return notification;
                      }

                      const additionalSubjectDetails =
                        await getGitifySubjectDetails(notification, accounts);

                      return {
                        ...notification,
                        subject: {
                          ...notification.subject,
                          ...additionalSubjectDetails,
                        },
                      };
                    },
                  ),
                ).then((notifications) => {
                  return notifications.filter((notification) => {
                    if (
                      !settings.showBots &&
                      notification.subject?.user?.type === 'Bot'
                    ) {
                      return false;
                    }

                    return true;
                  });
                }),
              };
            }),
          ).then((parsedNotifications) => {
            setNotifications(parsedNotifications);
            triggerNativeNotifications(
              notifications,
              parsedNotifications,
              settings,
              accounts,
            );
            setStatus('success');
          });
        })
        .catch((err: AxiosError<GitHubRESTError>) => {
          setStatus('error');
          setErrorDetails(determineFailureType(err));
        });
    },
    [notifications],
  );

  const markNotificationRead = useCallback(
    async (accounts: AuthState, id: string, hostname: string) => {
      setStatus('loading');

      const token = getTokenForHost(hostname, accounts);

      try {
        await markNotificationThreadAsRead(id, hostname, token);

        const updatedNotifications = removeNotification(
          id,
          notifications,
          hostname,
        );

        setNotifications(updatedNotifications);
        setTrayIconColor(updatedNotifications);
        setStatus('success');
      } catch (err) {
        setStatus('success');
      }
    },
    [notifications],
  );

  const markNotificationDone = useCallback(
    async (accounts: AuthState, id: string, hostname: string) => {
      setStatus('loading');

      const token = getTokenForHost(hostname, accounts);

      try {
        await markNotificationThreadAsDone(id, hostname, token);

        const updatedNotifications = removeNotification(
          id,
          notifications,
          hostname,
        );

        setNotifications(updatedNotifications);
        setTrayIconColor(updatedNotifications);
        setStatus('success');
      } catch (err) {
        setStatus('success');
      }
    },
    [notifications],
  );

  const unsubscribeNotification = useCallback(
    async (accounts: AuthState, id: string, hostname: string) => {
      setStatus('loading');

      const token = getTokenForHost(hostname, accounts);

      try {
        await ignoreNotificationThreadSubscription(id, hostname, token);
        await markNotificationRead(accounts, id, hostname);
        setStatus('success');
      } catch (err) {
        setStatus('success');
      }
    },
    [notifications],
  );

  const markRepoNotifications = useCallback(
    async (accounts: AuthState, repoSlug: string, hostname: string) => {
      setStatus('loading');

      const token = getTokenForHost(hostname, accounts);

      try {
        await markRepositoryNotificationsAsRead(repoSlug, hostname, token);
        const updatedNotifications = removeNotifications(
          repoSlug,
          notifications,
          hostname,
        );

        setNotifications(updatedNotifications);
        setTrayIconColor(updatedNotifications);
        setStatus('success');
      } catch (err) {
        setStatus('success');
      }
    },
    [notifications],
  );

  const markRepoNotificationsDone = useCallback(
    async (accounts: AuthState, repoSlug: string, hostname: string) => {
      setStatus('loading');

      try {
        const accountIndex = notifications.findIndex(
          (accountNotifications) => accountNotifications.hostname === hostname,
        );

        if (accountIndex !== -1) {
          const notificationsToRemove = notifications[
            accountIndex
          ].notifications.filter(
            (notification) => notification.repository.full_name === repoSlug,
          );

          await Promise.all(
            notificationsToRemove.map((notification) =>
              markNotificationDone(
                accounts,
                notification.id,
                notifications[accountIndex].hostname,
              ),
            ),
          );
        }

        const updatedNotifications = removeNotifications(
          repoSlug,
          notifications,
          hostname,
        );

        setNotifications(updatedNotifications);
        setTrayIconColor(updatedNotifications);
        setStatus('success');
      } catch (err) {
        setStatus('success');
      }
    },
    [notifications],
  );

  const removeNotificationFromState = useCallback(
    (id: string, hostname: string) => {
      const updatedNotifications = removeNotification(
        id,
        notifications,
        hostname,
      );

      setNotifications(updatedNotifications);
      setTrayIconColor(updatedNotifications);
    },
    [notifications],
  );

  return {
    status,
    errorDetails,
    notifications,

    removeNotificationFromState,
    fetchNotifications,
    markNotificationRead,
    markNotificationDone,
    unsubscribeNotification,
    markRepoNotifications,
    markRepoNotificationsDone,
  };
};

1	import type { AxiosError } from 'axios';
2	import { useCallback, useState } from 'react';	24✔
3
4	import type {
5	AccountNotifications,
6	AuthState,
7	GitifyError,
8	SettingsState,
9	Status,
10	} from '../types';
11	import type { GitHubRESTError, Notification } from '../typesGitHub';
12	import {	24✔
13	ignoreNotificationThreadSubscription,
14	listNotificationsForAuthenticatedUser,
15	markNotificationThreadAsDone,
16	markNotificationThreadAsRead,
17	markRepositoryNotificationsAsRead,
18	} from '../utils/api/client';
19	import { determineFailureType } from '../utils/api/errors';	24✔
20	import Constants from '../utils/constants';	24✔
21	import { getTokenForHost, isGitHubLoggedIn } from '../utils/helpers';	24✔
22	import {	24✔
23	setTrayIconColor,
24	triggerNativeNotifications,
25	} from '../utils/notifications';
26	import { removeNotification } from '../utils/remove-notification';	24✔
27	import { removeNotifications } from '../utils/remove-notifications';	24✔
28	import { getGitifySubjectDetails } from '../utils/subject';	24✔
29
30	interface NotificationsState {
31	notifications: AccountNotifications[];
32	removeNotificationFromState: (id: string, hostname: string) => void;
33	fetchNotifications: (
34	accounts: AuthState,
35	settings: SettingsState,
36	) => Promise<void>;
37	markNotificationRead: (
38	accounts: AuthState,
39	id: string,
40	hostname: string,
41	) => Promise<void>;
42	markNotificationDone: (
43	accounts: AuthState,
44	id: string,
45	hostname: string,
46	) => Promise<void>;
47	unsubscribeNotification: (
48	accounts: AuthState,
49	id: string,
50	hostname: string,
51	) => Promise<void>;
52	markRepoNotifications: (
53	accounts: AuthState,
54	repoSlug: string,
55	hostname: string,
56	) => Promise<void>;
57	markRepoNotificationsDone: (
58	accounts: AuthState,
59	repoSlug: string,
60	hostname: string,
61	) => Promise<void>;
62	status: Status;
63	errorDetails: GitifyError;
64	}
65
66	export const useNotifications = (): NotificationsState => {	24✔
67	const [status, setStatus] = useState<Status>('success');	172✔
68	const [errorDetails, setErrorDetails] = useState<GitifyError>();	172✔
69
70	const [notifications, setNotifications] = useState<AccountNotifications[]>(	172✔
71	[],
72	);
73
74	const fetchNotifications = useCallback(	172✔
75	async (accounts: AuthState, settings: SettingsState) => {
76	function getGitHubNotifications() {
77	if (!isGitHubLoggedIn(accounts)) {	18✔
78	return;	4✔
79	}
80
81	return listNotificationsForAuthenticatedUser(	14✔
82	Constants.DEFAULT_AUTH_OPTIONS.hostname,
83	accounts.token,
84	settings,
85	);
86	}
87
88	function getEnterpriseNotifications() {
89	return accounts.enterpriseAccounts.map((account) => {	18✔
90	return listNotificationsForAuthenticatedUser(	10✔
91	account.hostname,
92	account.token,
93	settings,
94	);
95	});
96	}
97
98	setStatus('loading');	18✔
99
100	return Promise.all([	18✔
101	getGitHubNotifications(),
102	...getEnterpriseNotifications(),
103	])
104	.then(([...responses]) => {
105	const accountsNotifications: AccountNotifications[] = responses	12✔
106	.filter((response) => !!response)	18✔
107	.map((accountNotifications) => {
108	const { hostname } = new URL(accountNotifications.config.url);	16✔
109	return {	16✔
110	hostname,
111	notifications: accountNotifications.data.map(
112	(notification: Notification) => ({	40✔
113	...notification,
114	hostname,
115	}),
116	),
117	};
118	});
119
120	Promise.all(	12✔
121	accountsNotifications.map(async (accountNotifications) => {
122	return {	16✔
123	hostname: accountNotifications.hostname,
124	notifications: await Promise.all<Notification>(
125	accountNotifications.notifications.map(
126	async (notification: Notification) => {
127	if (!settings.detailedNotifications) {	40✔
128	return notification;	24✔
129	}
130
131	const additionalSubjectDetails =
132	await getGitifySubjectDetails(notification, accounts);	16✔
133
134	return {	16✔
135	...notification,
136	subject: {
137	...notification.subject,
138	...additionalSubjectDetails,
139	},
140	};
141	},
142	),
143	).then((notifications) => {
144	return notifications.filter((notification) => {	16✔
145	if (	40✔
146	!settings.showBots &&	22✔
147	notification.subject?.user?.type === 'Bot'
148	) {
149	return false;	2✔
150	}
151
152	return true;	38✔
153	});
154	}),
155	};
156	}),
157	).then((parsedNotifications) => {
158	setNotifications(parsedNotifications);	12✔
159	triggerNativeNotifications(	12✔
160	notifications,
161	parsedNotifications,
162	settings,
163	accounts,
164	);
165	setStatus('success');	12✔
166	});
167	})
168	.catch((err: AxiosError<GitHubRESTError>) => {
169	setStatus('error');	6✔
170	setErrorDetails(determineFailureType(err));	6✔
171	});
172	},
173	[notifications],
174	);
175
176	const markNotificationRead = useCallback(	172✔
177	async (accounts: AuthState, id: string, hostname: string) => {
178	setStatus('loading');	12✔
179
180	const token = getTokenForHost(hostname, accounts);	12✔
181
182	try {	12✔
183	await markNotificationThreadAsRead(id, hostname, token);	12✔
184
185	const updatedNotifications = removeNotification(	8✔
186	id,
187	notifications,
188	hostname,
189	);
190
191	setNotifications(updatedNotifications);	8✔
192	setTrayIconColor(updatedNotifications);	8✔
193	setStatus('success');	8✔
194	} catch (err) {
195	setStatus('success');	4✔
196	}
197	},
198	[notifications],
199	);
200
201	const markNotificationDone = useCallback(	172✔
202	async (accounts: AuthState, id: string, hostname: string) => {
203	setStatus('loading');	8✔
204
205	const token = getTokenForHost(hostname, accounts);	8✔
206
207	try {	8✔
208	await markNotificationThreadAsDone(id, hostname, token);	8✔
209
210	const updatedNotifications = removeNotification(	4✔
211	id,
212	notifications,
213	hostname,
214	);
215
216	setNotifications(updatedNotifications);	4✔
217	setTrayIconColor(updatedNotifications);	4✔
218	setStatus('success');	4✔
219	} catch (err) {
220	setStatus('success');	4✔
221	}
222	},
223	[notifications],
224	);
225
226	const unsubscribeNotification = useCallback(	172✔
227	async (accounts: AuthState, id: string, hostname: string) => {
228	setStatus('loading');	8✔
229
230	const token = getTokenForHost(hostname, accounts);	8✔
231
232	try {	8✔
233	await ignoreNotificationThreadSubscription(id, hostname, token);	8✔
234	await markNotificationRead(accounts, id, hostname);	4✔
235	setStatus('success');	4✔
236	} catch (err) {
237	setStatus('success');	4✔
238	}
239	},
240	[notifications],
241	);
242
243	const markRepoNotifications = useCallback(	172✔
244	async (accounts: AuthState, repoSlug: string, hostname: string) => {
245	setStatus('loading');	8✔
246
247	const token = getTokenForHost(hostname, accounts);	8✔
248
249	try {	8✔
250	await markRepositoryNotificationsAsRead(repoSlug, hostname, token);	8✔
251	const updatedNotifications = removeNotifications(	4✔
252	repoSlug,
253	notifications,
254	hostname,
255	);
256
257	setNotifications(updatedNotifications);	4✔
258	setTrayIconColor(updatedNotifications);	4✔
259	setStatus('success');	4✔
260	} catch (err) {
261	setStatus('success');	4✔
262	}
263	},
264	[notifications],
265	);
266
267	const markRepoNotificationsDone = useCallback(	172✔
268	async (accounts: AuthState, repoSlug: string, hostname: string) => {
269	setStatus('loading');	8✔
270
271	try {	8✔
272	const accountIndex = notifications.findIndex(	8✔
UNCOV 273	(accountNotifications) => accountNotifications.hostname === hostname,	×
274	);
275
276	if (accountIndex !== -1) {	8!
UNCOV 277	const notificationsToRemove = notifications[	×
278	accountIndex
279	].notifications.filter(
UNCOV 280	(notification) => notification.repository.full_name === repoSlug,	×
281	);
282
UNCOV 283	await Promise.all(	×
284	notificationsToRemove.map((notification) =>
285	markNotificationDone(	×
286	accounts,
287	notification.id,
288	notifications[accountIndex].hostname,
289	),
290	),
291	);
292	}
293
294	const updatedNotifications = removeNotifications(	8✔
295	repoSlug,
296	notifications,
297	hostname,
298	);
299
300	setNotifications(updatedNotifications);	8✔
301	setTrayIconColor(updatedNotifications);	8✔
302	setStatus('success');	8✔
303	} catch (err) {
UNCOV 304	setStatus('success');	×
305	}
306	},
307	[notifications],
308	);
309
310	const removeNotificationFromState = useCallback(	172✔
311	(id: string, hostname: string) => {
312	const updatedNotifications = removeNotification(	2✔
313	id,
314	notifications,
315	hostname,
316	);
317
318	setNotifications(updatedNotifications);	2✔
319	setTrayIconColor(updatedNotifications);	2✔
320	},
321	[notifications],
322	);
323
324	return {	172✔
325	status,
326	errorDetails,
327	notifications,
328
329	removeNotificationFromState,
330	fetchNotifications,
331	markNotificationRead,
332	markNotificationDone,
333	unsubscribeNotification,
334	markRepoNotifications,
335	markRepoNotificationsDone,
336	};
337	};

gitify-app / gitify / 8917566083

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