9447663235

Committed 10 Jun 2024 11:41AM UTC coverage: 96.734% (-0.2%) from 96.921%

Build # 9447663235

Build Type

Pull #1201

github

Committed by

web-flow

Commit Message

Merge ad5d9fe8f into 4f4a983e2

Pull Request Pull Request #1201: feat: support multiple accounts

Run Details

440 of 451 branches covered (97.56%)

Branch coverage included in aggregate %.

40 of 44 new or added lines in 11 files covered. (90.91%)

1 existing line in 1 file now uncovered.

1130 of 1172 relevant lines covered (96.42%)

19.61 hits per line

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

87.34

/src/hooks/useNotifications.ts

import { useCallback, useState } from 'react';
import type {
  AccountNotifications,
  GitifyError,
  GitifyState,
  SettingsState,
  Status,
} from '../types';
import type { Notification } from '../typesGitHub';
import {
  ignoreNotificationThreadSubscription,
  markNotificationThreadAsDone,
  markNotificationThreadAsRead,
  markRepositoryNotificationsAsRead,
} from '../utils/api/client';
import { determineFailureType } from '../utils/api/errors';
import { getAccountUUID } from '../utils/auth/utils';
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,
    notification: Notification,
  ) => void;
  fetchNotifications: (state: GitifyState) => Promise<void>;
  markNotificationRead: (
    state: GitifyState,
    notification: Notification,
  ) => Promise<void>;
  markNotificationDone: (
    state: GitifyState,
    notification: Notification,
  ) => Promise<void>;
  unsubscribeNotification: (
    state: GitifyState,
    notification: Notification,
  ) => Promise<void>;
  markRepoNotificationsRead: (
    state: GitifyState,
    notification: Notification,
  ) => Promise<void>;
  markRepoNotificationsDone: (
    state: GitifyState,
    notification: Notification,
  ) => 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 (state: GitifyState) => {
      setStatus('loading');

      try {
        const fetchedNotifications = await getAllNotifications(state);

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

  const markNotificationRead = useCallback(
    async (state: GitifyState, notification: Notification) => {
      setStatus('loading');

      try {
        await markNotificationThreadAsRead(
          notification.id,
          notification.account.hostname,
          notification.account.token,
        );

        const updatedNotifications = removeNotification(
          state.settings,
          notification,
          notifications,
        );

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

  const markNotificationDone = useCallback(
    async (state: GitifyState, notification: Notification) => {
      setStatus('loading');

      try {
        await markNotificationThreadAsDone(
          notification.id,
          notification.account.hostname,
          notification.account.token,
        );

        const updatedNotifications = removeNotification(
          state.settings,
          notification,
          notifications,
        );

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

  const unsubscribeNotification = useCallback(
    async (state: GitifyState, notification: Notification) => {
      setStatus('loading');

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

  const markRepoNotificationsRead = useCallback(
    async (state: GitifyState, notification: Notification) => {
      setStatus('loading');

      const repoSlug = notification.repository.full_name;
      const hostname = notification.account.hostname;

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

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

  const markRepoNotificationsDone = useCallback(
    async (state: GitifyState, notification: Notification) => {
      setStatus('loading');

      const repoSlug = notification.repository.full_name;

      try {
        const accountIndex = notifications.findIndex(
          (accountNotifications) =>
            getAccountUUID(accountNotifications.account) ===
            getAccountUUID(notification.account),
        );

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

          await Promise.all(
            notificationsToRemove.map((notification) =>
              markNotificationDone(state, notification),
            ),
          );
        }

        const updatedNotifications = removeNotifications(
          notification,
          notifications,
        );

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

  const removeNotificationFromState = useCallback(
    (settings: SettingsState, notification: Notification) => {
      const updatedNotifications = removeNotification(
        settings,
        notification,
        notifications,
      );

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

  return {
    status,
    errorDetails,
    notifications,

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

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

gitify-app / gitify / 9447663235

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