10317915949

Committed 09 Aug 2024 10:42AM UTC coverage: 97.15% (+0.3%) from 96.863%

Build # 10317915949

Build Type

push

github

Committed by

web-flow

Commit Message

fix: openLinks on first login screen (#1451)

* fix: openLinks

* fix: load default state when non existing

Signed-off-by: Adam Setch <adam.setch@outlook.com>

---------

Signed-off-by: Adam Setch <adam.setch@outlook.com>
Co-authored-by: Adam Setch <adam.setch@outlook.com>

Run Details

584 of 599 branches covered (97.5%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 2 files covered. (100.0%)

1 existing line in 1 file now uncovered.

1461 of 1506 relevant lines covered (97.01%)

26.23 hits per line

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

76.27

/src/context/App.tsx

import { ipcRenderer, webFrame } from 'electron';
import {
  type ReactNode,
  createContext,
  useCallback,
  useEffect,
  useMemo,
  useState,
} from 'react';
import { useInterval } from '../hooks/useInterval';
import { useNotifications } from '../hooks/useNotifications';
import {
  type Account,
  type AccountNotifications,
  type AuthState,
  type GitifyError,
  GroupBy,
  OpenPreference,
  type SettingsState,
  type SettingsValue,
  type Status,
  Theme,
} from '../types';
import type { Notification } from '../typesGitHub';
import { headNotifications } from '../utils/api/client';
import { migrateAuthenticatedAccounts } from '../utils/auth/migration';
import type {
  LoginOAuthAppOptions,
  LoginPersonalAccessTokenOptions,
} from '../utils/auth/types';
import {
  addAccount,
  authGitHub,
  getToken,
  getUserData,
  removeAccount,
} from '../utils/auth/utils';
import {
  setAutoLaunch,
  setKeyboardShortcut,
  updateTrayTitle,
} from '../utils/comms';
import Constants from '../utils/constants';
import { getNotificationCount } from '../utils/notifications';
import { clearState, loadState, saveState } from '../utils/storage';
import { setTheme } from '../utils/theme';
import { zoomPercentageToLevel } from '../utils/zoom';

export const defaultAuth: AuthState = {
  accounts: [],
  token: null,
  enterpriseAccounts: [],
  user: null,
};

const defaultAppearanceSettings = {
  theme: Theme.SYSTEM,
  zoomPercentage: 100,
  detailedNotifications: true,
  showPills: true,
  showNumber: true,
  showAccountHostname: false,
};

const defaultNotificationSettings = {
  groupBy: GroupBy.REPOSITORY,
  participating: false,
  markAsDoneOnOpen: false,
  delayNotificationState: false,
};

const defaultSystemSettings = {
  openLinks: OpenPreference.FOREGROUND,
  keyboardShortcut: true,
  showNotificationsCountInTray: false,
  showNotifications: true,
  playSound: true,
  openAtStartup: false,
};

export const defaultFilters = {
  hideBots: false,
  filterReasons: [],
};

export const defaultSettings: SettingsState = {
  ...defaultAppearanceSettings,
  ...defaultNotificationSettings,
  ...defaultSystemSettings,
  ...defaultFilters,
};

interface AppContextState {
  auth: AuthState;
  isLoggedIn: boolean;
  loginWithGitHubApp: () => void;
  loginWithOAuthApp: (data: LoginOAuthAppOptions) => void;
  loginWithPersonalAccessToken: (data: LoginPersonalAccessTokenOptions) => void;
  logoutFromAccount: (account: Account) => void;

  notifications: AccountNotifications[];
  status: Status;
  globalError: GitifyError;
  fetchNotifications: () => Promise<void>;
  markNotificationRead: (notification: Notification) => Promise<void>;
  markNotificationDone: (notification: Notification) => Promise<void>;
  unsubscribeNotification: (notification: Notification) => Promise<void>;
  markRepoNotificationsRead: (notification: Notification) => Promise<void>;
  markRepoNotificationsDone: (notification: Notification) => Promise<void>;

  settings: SettingsState;
  clearFilters: () => void;
  resetSettings: () => void;
  updateSetting: (name: keyof SettingsState, value: SettingsValue) => void;
}

export const AppContext = createContext<Partial<AppContextState>>({});

export const AppProvider = ({ children }: { children: ReactNode }) => {
  const [auth, setAuth] = useState<AuthState>(defaultAuth);
  const [settings, setSettings] = useState<SettingsState>(defaultSettings);
  const {
    fetchNotifications,
    notifications,
    globalError,
    status,
    markNotificationRead,
    markNotificationDone,
    unsubscribeNotification,
    markRepoNotificationsRead,
    markRepoNotificationsDone,
  } = useNotifications();

  useEffect(() => {
    restoreSettings();
  }, []);

  useEffect(() => {
    setTheme(settings.theme);
  }, [settings.theme]);

  // biome-ignore lint/correctness/useExhaustiveDependencies: We only want fetchNotifications to be called for account changes
  useEffect(() => {
    fetchNotifications({ auth, settings });
  }, [auth.accounts]);

  useInterval(() => {
    fetchNotifications({ auth, settings });
  }, Constants.FETCH_INTERVAL);

  useEffect(() => {
    const count = getNotificationCount(notifications);

    if (settings.showNotificationsCountInTray && count > 0) {
      updateTrayTitle(count.toString());
    } else {
      updateTrayTitle();
    }
  }, [settings.showNotificationsCountInTray, notifications]);

  useEffect(() => {
    setKeyboardShortcut(settings.keyboardShortcut);
  }, [settings.keyboardShortcut]);

  useEffect(() => {
    ipcRenderer.on('gitify:reset-app', () => {
      setAuth(defaultAuth);
      clearState();
    });
  }, []);

  const clearFilters = useCallback(() => {
    const newSettings = { ...settings, ...defaultFilters };
    setSettings(newSettings);
    saveState({ auth, settings: newSettings });
  }, [auth, settings]);

  const resetSettings = useCallback(() => {
    setSettings(defaultSettings);
    saveState({ auth, settings: defaultSettings });
  }, [auth]);

  const updateSetting = useCallback(
    (name: keyof SettingsState, value: SettingsValue) => {
      if (name === 'openAtStartup') {
        setAutoLaunch(value as boolean);
      }

      const newSettings = { ...settings, [name]: value };
      setSettings(newSettings);
      saveState({ auth, settings: newSettings });
    },
    [auth, settings],
  );

  const isLoggedIn = useMemo(() => {
    return auth.accounts.length > 0;
  }, [auth]);

  const loginWithGitHubApp = useCallback(async () => {
    const { authCode } = await authGitHub();
    const { token } = await getToken(authCode);
    const hostname = Constants.DEFAULT_AUTH_OPTIONS.hostname;
    const user = await getUserData(token, hostname);
    const updatedAuth = addAccount(auth, 'GitHub App', token, hostname, user);
    setAuth(updatedAuth);
    saveState({ auth: updatedAuth, settings });
  }, [auth, settings]);

  const loginWithOAuthApp = useCallback(
    async (data: LoginOAuthAppOptions) => {
      const { authOptions, authCode } = await authGitHub(data);
      const { token, hostname } = await getToken(authCode, authOptions);
      const user = await getUserData(token, hostname);
      const updatedAuth = addAccount(auth, 'OAuth App', token, hostname, user);
      setAuth(updatedAuth);
      saveState({ auth: updatedAuth, settings });
    },
    [auth, settings],
  );

  const loginWithPersonalAccessToken = useCallback(
    async ({ token, hostname }: LoginPersonalAccessTokenOptions) => {
      await headNotifications(hostname, token);
      const user = await getUserData(token, hostname);
      const updatedAuth = addAccount(
        auth,
        'Personal Access Token',
        token,
        hostname,
        user,
      );
      setAuth(updatedAuth);
      saveState({ auth: updatedAuth, settings });
    },
    [auth, settings],
  );

  const logoutFromAccount = useCallback(
    async (account: Account) => {
      const updatedAuth = removeAccount(auth, account);
      setAuth(updatedAuth);
      saveState({ auth: updatedAuth, settings });
    },
    [auth, settings],
  );

  const restoreSettings = useCallback(async () => {
    await migrateAuthenticatedAccounts();

    const existing = loadState();

    if (existing.auth) {
      setAuth({ ...defaultAuth, ...existing.auth });
    }

    if (existing.settings) {
      setKeyboardShortcut(existing.settings.keyboardShortcut);
      setSettings({ ...defaultSettings, ...existing.settings });
      webFrame.setZoomLevel(
        zoomPercentageToLevel(existing.settings.zoomPercentage),
      );
      return existing.settings;
    }

    for (const account of auth.accounts.filter(
      (a) => a.platform === 'GitHub Enterprise Server',
    )) {
      const res = await headNotifications(account.hostname, account.token);
      account.version = res.headers['x-github-enterprise-version'];
    }
  }, []);

  const fetchNotificationsWithAccounts = useCallback(
    async () => await fetchNotifications({ auth, settings }),
    [auth, settings, fetchNotifications],
  );

  const markNotificationReadWithAccounts = useCallback(
    async (notification: Notification) =>
      await markNotificationRead({ auth, settings }, notification),
    [auth, settings, markNotificationRead],
  );

  const markNotificationDoneWithAccounts = useCallback(
    async (notification: Notification) =>
      await markNotificationDone({ auth, settings }, notification),
    [auth, settings, markNotificationDone],
  );

  const unsubscribeNotificationWithAccounts = useCallback(
    async (notification: Notification) =>
      await unsubscribeNotification({ auth, settings }, notification),
    [auth, settings, unsubscribeNotification],
  );

  const markRepoNotificationsReadWithAccounts = useCallback(
    async (notification: Notification) =>
      await markRepoNotificationsRead({ auth, settings }, notification),
    [auth, settings, markRepoNotificationsRead],
  );

  const markRepoNotificationsDoneWithAccounts = useCallback(
    async (notification: Notification) =>
      await markRepoNotificationsDone({ auth, settings }, notification),
    [auth, settings, markRepoNotificationsDone],
  );

  return (
    <AppContext.Provider
      value={{
        auth,
        isLoggedIn,
        loginWithGitHubApp,
        loginWithOAuthApp,
        loginWithPersonalAccessToken,
        logoutFromAccount,

        notifications,
        status,
        globalError,
        fetchNotifications: fetchNotificationsWithAccounts,
        markNotificationRead: markNotificationReadWithAccounts,
        markNotificationDone: markNotificationDoneWithAccounts,
        unsubscribeNotification: unsubscribeNotificationWithAccounts,
        markRepoNotificationsRead: markRepoNotificationsReadWithAccounts,
        markRepoNotificationsDone: markRepoNotificationsDoneWithAccounts,

        settings,
        clearFilters,
        resetSettings,
        updateSetting,
      }}
    >
      {children}
    </AppContext.Provider>
  );
};

1	import { ipcRenderer, webFrame } from 'electron';	72✔
2	import {	72✔
3	type ReactNode,
4	createContext,
5	useCallback,
6	useEffect,
7	useMemo,
8	useState,
9	} from 'react';
10	import { useInterval } from '../hooks/useInterval';	72✔
11	import { useNotifications } from '../hooks/useNotifications';	72✔
12	import {	72✔
13	type Account,
14	type AccountNotifications,
15	type AuthState,
16	type GitifyError,
17	GroupBy,
18	OpenPreference,
19	type SettingsState,
20	type SettingsValue,
21	type Status,
22	Theme,
23	} from '../types';
24	import type { Notification } from '../typesGitHub';
25	import { headNotifications } from '../utils/api/client';	72✔
26	import { migrateAuthenticatedAccounts } from '../utils/auth/migration';	72✔
27	import type {
28	LoginOAuthAppOptions,
29	LoginPersonalAccessTokenOptions,
30	} from '../utils/auth/types';
31	import {	72✔
32	addAccount,
33	authGitHub,
34	getToken,
35	getUserData,
36	removeAccount,
37	} from '../utils/auth/utils';
38	import {	72✔
39	setAutoLaunch,
40	setKeyboardShortcut,
41	updateTrayTitle,
42	} from '../utils/comms';
43	import Constants from '../utils/constants';	72✔
44	import { getNotificationCount } from '../utils/notifications';	72✔
45	import { clearState, loadState, saveState } from '../utils/storage';	72✔
46	import { setTheme } from '../utils/theme';	72✔
47	import { zoomPercentageToLevel } from '../utils/zoom';	72✔
48
49	export const defaultAuth: AuthState = {	72✔
50	accounts: [],
51	token: null,
52	enterpriseAccounts: [],
53	user: null,
54	};
55
56	const defaultAppearanceSettings = {	72✔
57	theme: Theme.SYSTEM,
58	zoomPercentage: 100,
59	detailedNotifications: true,
60	showPills: true,
61	showNumber: true,
62	showAccountHostname: false,
63	};
64
65	const defaultNotificationSettings = {	72✔
66	groupBy: GroupBy.REPOSITORY,
67	participating: false,
68	markAsDoneOnOpen: false,
69	delayNotificationState: false,
70	};
71
72	const defaultSystemSettings = {	72✔
73	openLinks: OpenPreference.FOREGROUND,
74	keyboardShortcut: true,
75	showNotificationsCountInTray: false,
76	showNotifications: true,
77	playSound: true,
78	openAtStartup: false,
79	};
80
81	export const defaultFilters = {	72✔
82	hideBots: false,
83	filterReasons: [],
84	};
85
86	export const defaultSettings: SettingsState = {	72✔
87	...defaultAppearanceSettings,
88	...defaultNotificationSettings,
89	...defaultSystemSettings,
90	...defaultFilters,
91	};
92
93	interface AppContextState {
94	auth: AuthState;
95	isLoggedIn: boolean;
96	loginWithGitHubApp: () => void;
97	loginWithOAuthApp: (data: LoginOAuthAppOptions) => void;
98	loginWithPersonalAccessToken: (data: LoginPersonalAccessTokenOptions) => void;
99	logoutFromAccount: (account: Account) => void;
100
101	notifications: AccountNotifications[];
102	status: Status;
103	globalError: GitifyError;
104	fetchNotifications: () => Promise<void>;
105	markNotificationRead: (notification: Notification) => Promise<void>;
106	markNotificationDone: (notification: Notification) => Promise<void>;
107	unsubscribeNotification: (notification: Notification) => Promise<void>;
108	markRepoNotificationsRead: (notification: Notification) => Promise<void>;
109	markRepoNotificationsDone: (notification: Notification) => Promise<void>;
110
111	settings: SettingsState;
112	clearFilters: () => void;
113	resetSettings: () => void;
114	updateSetting: (name: keyof SettingsState, value: SettingsValue) => void;
115	}
116
117	export const AppContext = createContext<Partial<AppContextState>>({});	72✔
118
119	export const AppProvider = ({ children }: { children: ReactNode }) => {	72✔
120	const [auth, setAuth] = useState<AuthState>(defaultAuth);	30✔
121	const [settings, setSettings] = useState<SettingsState>(defaultSettings);	30✔
122	const {
123	fetchNotifications,
124	notifications,
125	globalError,
126	status,
127	markNotificationRead,
128	markNotificationDone,
129	unsubscribeNotification,
130	markRepoNotificationsRead,
131	markRepoNotificationsDone,
132	} = useNotifications();	30✔
133
134	useEffect(() => {	30✔
135	restoreSettings();	24✔
136	}, []);
137
138	useEffect(() => {	30✔
139	setTheme(settings.theme);	24✔
140	}, [settings.theme]);
141
142	// biome-ignore lint/correctness/useExhaustiveDependencies: We only want fetchNotifications to be called for account changes
143	useEffect(() => {	30✔
144	fetchNotifications({ auth, settings });	24✔
145	}, [auth.accounts]);
146
147	useInterval(() => {	30✔
148	fetchNotifications({ auth, settings });	6✔
149	}, Constants.FETCH_INTERVAL);
150
151	useEffect(() => {	30✔
152	const count = getNotificationCount(notifications);	24✔
153
154	if (settings.showNotificationsCountInTray && count > 0) {	24!
155	updateTrayTitle(count.toString());	×
156	} else {
157	updateTrayTitle();	24✔
158	}
159	}, [settings.showNotificationsCountInTray, notifications]);
160
161	useEffect(() => {	30✔
162	setKeyboardShortcut(settings.keyboardShortcut);	24✔
163	}, [settings.keyboardShortcut]);
164
165	useEffect(() => {	30✔
166	ipcRenderer.on('gitify:reset-app', () => {	24✔
167	setAuth(defaultAuth);	×
168	clearState();	×
169	});
170	}, []);
171
172	const clearFilters = useCallback(() => {	30✔
173	const newSettings = { ...settings, ...defaultFilters };	2✔
174	setSettings(newSettings);	2✔
175	saveState({ auth, settings: newSettings });	2✔
176	}, [auth, settings]);
177
178	const resetSettings = useCallback(() => {	30✔
179	setSettings(defaultSettings);	2✔
180	saveState({ auth, settings: defaultSettings });	2✔
181	}, [auth]);
182
183	const updateSetting = useCallback(	30✔
184	(name: keyof SettingsState, value: SettingsValue) => {
185	if (name === 'openAtStartup') {	4✔
186	setAutoLaunch(value as boolean);	2✔
187	}
188
189	const newSettings = { ...settings, [name]: value };	4✔
190	setSettings(newSettings);	4✔
191	saveState({ auth, settings: newSettings });	4✔
192	},
193	[auth, settings],
194	);
195
196	const isLoggedIn = useMemo(() => {	30✔
197	return auth.accounts.length > 0;	24✔
198	}, [auth]);
199
200	const loginWithGitHubApp = useCallback(async () => {	30✔
201	const { authCode } = await authGitHub();	×
202	const { token } = await getToken(authCode);	×
203	const hostname = Constants.DEFAULT_AUTH_OPTIONS.hostname;	×
204	const user = await getUserData(token, hostname);	×
205	const updatedAuth = addAccount(auth, 'GitHub App', token, hostname, user);	×
206	setAuth(updatedAuth);	×
207	saveState({ auth: updatedAuth, settings });	×
208	}, [auth, settings]);
209
210	const loginWithOAuthApp = useCallback(	30✔
211	async (data: LoginOAuthAppOptions) => {
212	const { authOptions, authCode } = await authGitHub(data);	×
213	const { token, hostname } = await getToken(authCode, authOptions);	×
214	const user = await getUserData(token, hostname);	×
215	const updatedAuth = addAccount(auth, 'OAuth App', token, hostname, user);	×
216	setAuth(updatedAuth);	×
217	saveState({ auth: updatedAuth, settings });	×
218	},
219	[auth, settings],
220	);
221
222	const loginWithPersonalAccessToken = useCallback(	30✔
223	async ({ token, hostname }: LoginPersonalAccessTokenOptions) => {
224	await headNotifications(hostname, token);	2✔
225	const user = await getUserData(token, hostname);	2✔
226	const updatedAuth = addAccount(	×
227	auth,
228	'Personal Access Token',
229	token,
230	hostname,
231	user,
232	);
233	setAuth(updatedAuth);	×
234	saveState({ auth: updatedAuth, settings });	×
235	},
236	[auth, settings],
237	);
238
239	const logoutFromAccount = useCallback(	30✔
240	async (account: Account) => {
241	const updatedAuth = removeAccount(auth, account);	×
242	setAuth(updatedAuth);	×
243	saveState({ auth: updatedAuth, settings });	×
244	},
245	[auth, settings],
246	);
247
248	const restoreSettings = useCallback(async () => {	30✔
249	await migrateAuthenticatedAccounts();	24✔
250
251	const existing = loadState();	24✔
252
253	if (existing.auth) {	24✔
254	setAuth({ ...defaultAuth, ...existing.auth });	24✔
255	}
256
257	if (existing.settings) {	24✔
258	setKeyboardShortcut(existing.settings.keyboardShortcut);	24✔
259	setSettings({ ...defaultSettings, ...existing.settings });	24✔
260	webFrame.setZoomLevel(	24✔
261	zoomPercentageToLevel(existing.settings.zoomPercentage),
262	);
263	return existing.settings;	24✔
264	}
265
UNCOV 266	for (const account of auth.accounts.filter(	×
267	(a) => a.platform === 'GitHub Enterprise Server',	×
268	)) {
269	const res = await headNotifications(account.hostname, account.token);	×
270	account.version = res.headers['x-github-enterprise-version'];	×
271	}
272	}, []);
273
274	const fetchNotificationsWithAccounts = useCallback(	30✔
275	async () => await fetchNotifications({ auth, settings }),	2✔
276	[auth, settings, fetchNotifications],
277	);
278
279	const markNotificationReadWithAccounts = useCallback(	30✔
280	async (notification: Notification) =>
281	await markNotificationRead({ auth, settings }, notification),	2✔
282	[auth, settings, markNotificationRead],
283	);
284
285	const markNotificationDoneWithAccounts = useCallback(	30✔
286	async (notification: Notification) =>
287	await markNotificationDone({ auth, settings }, notification),	2✔
288	[auth, settings, markNotificationDone],
289	);
290
291	const unsubscribeNotificationWithAccounts = useCallback(	30✔
292	async (notification: Notification) =>
293	await unsubscribeNotification({ auth, settings }, notification),	2✔
294	[auth, settings, unsubscribeNotification],
295	);
296
297	const markRepoNotificationsReadWithAccounts = useCallback(	30✔
298	async (notification: Notification) =>
299	await markRepoNotificationsRead({ auth, settings }, notification),	2✔
300	[auth, settings, markRepoNotificationsRead],
301	);
302
303	const markRepoNotificationsDoneWithAccounts = useCallback(	30✔
304	async (notification: Notification) =>
305	await markRepoNotificationsDone({ auth, settings }, notification),	2✔
306	[auth, settings, markRepoNotificationsDone],
307	);
308
309	return (	30✔
310	<AppContext.Provider
311	value={{
312	auth,
313	isLoggedIn,
314	loginWithGitHubApp,
315	loginWithOAuthApp,
316	loginWithPersonalAccessToken,
317	logoutFromAccount,
318
319	notifications,
320	status,
321	globalError,
322	fetchNotifications: fetchNotificationsWithAccounts,
323	markNotificationRead: markNotificationReadWithAccounts,
324	markNotificationDone: markNotificationDoneWithAccounts,
325	unsubscribeNotification: unsubscribeNotificationWithAccounts,
326	markRepoNotificationsRead: markRepoNotificationsReadWithAccounts,
327	markRepoNotificationsDone: markRepoNotificationsDoneWithAccounts,
328
329	settings,
330	clearFilters,
331	resetSettings,
332	updateSetting,
333	}}
334	>
335	{children}
336	</AppContext.Provider>
337	);
338	};

gitify-app / gitify / 10317915949

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