9207063419

Committed 23 May 2024 11:19AM UTC coverage: 96.693% (+0.05%) from 96.642%

Build # 9207063419

Build Type

Pull #1139

github

Committed by

web-flow

Commit Message

Merge 2362a2b95 into 252bae4de

Pull Request Pull Request #1139: feat(accounts): new account system

Run Details

412 of 423 branches covered (97.4%)

Branch coverage included in aggregate %.

46 of 49 new or added lines in 11 files covered. (93.88%)

10 existing lines in 3 files now uncovered.

1050 of 1089 relevant lines covered (96.42%)

20.76 hits per line

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

90.0

/src/hooks/useNotifications.ts

import { useCallback, useState } from 'react';

import type {
  AccountNotifications,
  AuthState,
  GitifyError,
  SettingsState,
  Status,
} from '../types';
import {
  ignoreNotificationThreadSubscription,
  markNotificationThreadAsDone,
  markNotificationThreadAsRead,
  markRepositoryNotificationsAsRead,
} from '../utils/api/client';
import { determineFailureType } from '../utils/api/errors';
import { getTokenForHost } from '../utils/helpers';
import {
  getAllNotifications,
  setTrayIconColor,
  triggerNativeNotifications,
} from '../utils/notifications';
import { removeNotification } from '../utils/remove-notification';
import { removeNotifications } from '../utils/remove-notifications';

interface NotificationsState {
  notifications: AccountNotifications[];
  removeNotificationFromState: (
    settings: SettingsState,
    id: string,
    hostname: string,
  ) => void;
  fetchNotifications: (
    accounts: AuthState,
    settings: SettingsState,
  ) => Promise<void>;
  markNotificationRead: (
    accounts: AuthState,
    settings: SettingsState,
    id: string,
    hostname: string,
  ) => Promise<void>;
  markNotificationDone: (
    accounts: AuthState,
    settings: SettingsState,
    id: string,
    hostname: string,
  ) => Promise<void>;
  unsubscribeNotification: (
    accounts: AuthState,
    settings: SettingsState,
    id: string,
    hostname: string,
  ) => Promise<void>;
  markRepoNotifications: (
    accounts: AuthState,
    settings: SettingsState,
    repoSlug: string,
    hostname: string,
  ) => Promise<void>;
  markRepoNotificationsDone: (
    accounts: AuthState,
    settings: SettingsState,
    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) => {
      setStatus('loading');

      try {
        const fetchedNotifications = await getAllNotifications(
          accounts,
          settings,
        );

        setNotifications(fetchedNotifications);
        triggerNativeNotifications(
          notifications,
          fetchedNotifications,
          settings,
          accounts,
        );
        setStatus('success');
      } catch (err) {
        setStatus('error');
        setErrorDetails(determineFailureType(err));
      }
    },
    [notifications],
  );

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

      const token = getTokenForHost(hostname, accounts);

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

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

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

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

      const token = getTokenForHost(hostname, accounts);

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

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

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

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

      const token = getTokenForHost(hostname, accounts);

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

  const markRepoNotifications = useCallback(
    async (
      accounts: AuthState,
      settings: SettingsState,
      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,
      settings: SettingsState,
      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,
                settings,
                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(
    (settings: SettingsState, id: string, hostname: string) => {
      const updatedNotifications = removeNotification(
        settings,
        id,
        notifications,
        hostname,
      );

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

  return {
    status,
    errorDetails,
    notifications,

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

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

gitify-app / gitify / 9207063419

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