10394257115

Committed 14 Aug 2024 08:06PM UTC coverage: 15.843% (+15.4%) from 0.438%

Build # 10394257115

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #8796 from hicommonwealth/burton/update-eslint

Errors for promise issues in eslint...

Run Details

3601 of 21136 branches covered (17.04%)

Branch coverage included in aggregate %.

3 of 8 new or added lines in 3 files covered. (37.5%)

2 existing lines in 1 file now uncovered.

4712 of 31334 relevant lines covered (15.04%)

5.1 hits per line

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

0.0

/packages/commonwealth/client/scripts/views/pages/NotificationSettingsOld/useNotificationSettings.tsx

import { NotificationCategories } from '@hicommonwealth/shared';
import { getMultipleSpacesById } from 'helpers/snapshot_utils';
import useForceRerender from 'hooks/useForceRerender';
import 'pages/notification_settings/index.scss';
import { useEffect, useState } from 'react';
import app from 'state';
import useUserStore from 'state/ui/user';
import NotificationSubscription from '../../../models/NotificationSubscription';
import { bundleSubs, extractSnapshotProposals } from './helpers';

export type SnapshotInfo = {
  snapshotId: string;
  space: {
    avatar: string;
    name: string;
  };
  subs: Array<NotificationSubscription>;
};

const useNotificationSettings = () => {
  const forceRerender = useForceRerender();
  const [email, setEmail] = useState('');
  const [emailValidated, setEmailValidated] = useState(false);
  const [sentEmail, setSentEmail] = useState(false);
  const [snapshotsInfo, setSnapshotsInfo] = useState(null);

  const user = useUserStore();

  const [currentFrequency, setCurrentFrequency] = useState(
    user.emailNotificationInterval,
  );

  useEffect(() => {
    app.user.notifications.isLoaded.once('redraw', forceRerender);
  }, [forceRerender]);

  useEffect(() => {
    // bundled snapshot subscriptions
    const bundledSnapshotSubs = extractSnapshotProposals(
      app.user.notifications.discussionSubscriptions,
    );
    const snapshotIds = Object.keys(bundledSnapshotSubs);

    const getSpaces = async () => {
      try {
        const getSpaceById = await getMultipleSpacesById(snapshotIds);

        const snapshotsInfoArr = snapshotIds.map((snapshotId) => ({
          snapshotId,
          space: getSpaceById.find((x: { id: string }) => x.id === snapshotId),
          subs: bundledSnapshotSubs[snapshotId],
        }));

        // @ts-expect-error StrictNullChecks
        setSnapshotsInfo(snapshotsInfoArr);
      } catch (err) {
        console.error(err);
        return null;
      }
    };

    getSpaces().catch(console.error);
  }, []);

  const handleSubscriptions = async (
    hasSomeInAppSubs: boolean,
    subs: NotificationSubscription[],
  ) => {
    if (hasSomeInAppSubs) {
      await app.user.notifications.disableSubscriptions(subs);
    } else {
      await app.user.notifications.enableSubscriptions(subs);
    }
    forceRerender();
  };

  const handleEmailSubscriptions = async (
    hasSomeEmailSubs: boolean,
    subs: NotificationSubscription[],
  ) => {
    if (hasSomeEmailSubs) {
      await app.user.notifications.disableImmediateEmails(subs);
    } else {
      await app.user.notifications.enableImmediateEmails(subs);
    }
    forceRerender();
  };

  const handleUnsubscribe = async (subscription: NotificationSubscription) => {
    await app.user.notifications.deleteSubscription(subscription);
    forceRerender();
  };

  // bundled discussion subscriptions
  const bundledSubs = bundleSubs(
    app?.user.notifications.discussionSubscriptions,
  );

  // bundled chain-event subscriptions
  const chainEventSubs = bundleSubs(
    app?.user.notifications.chainEventSubscriptions,
  );

  const subscribedCommunityIds =
    app?.user.notifications.chainEventSubscribedChainIds;

  // communities the user has addresses for but does not have existing subscriptions for
  const relevantSubscribedCommunities = user.addresses
    ?.map?.((x) => x?.community)
    ?.filter?.(
      (x) =>
        subscribedCommunityIds?.includes?.(x?.id) && !chainEventSubs?.[x?.id],
    );

  const toggleAllInAppNotifications = async (enableAll: boolean) => {
    const subIds = [];

    // get all subscription ids
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    Object.entries(chainEventSubs).map(([_, subs]) =>
      // @ts-expect-error StrictNullChecks
      subIds.push(...(subs || [])),
    );
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    Object.entries(bundledSubs).map(([_, subs]) =>
      // @ts-expect-error StrictNullChecks
      subIds.push(...(subs || [])),
    );
    // @ts-expect-error StrictNullChecks
    snapshotsInfo?.map(({ snapshotId, subs }: SnapshotInfo) => {
      // @ts-expect-error StrictNullChecks
      if (snapshotId) subIds.push(...(subs || []));
    });

    // enable/disable all subscriptions
    await handleSubscriptions(!enableAll, subIds);
    await handleEmailSubscriptions(!enableAll, subIds);
    if (enableAll) {
      relevantSubscribedCommunities
        .sort((x, y) => x.name.localeCompare(y.name))
        .map((community) => {
          app.user.notifications
            .subscribe({
              categoryId: NotificationCategories.ChainEvent,
              options: { communityId: community.id },
            })
            .catch(console.error);
        });
    }
  };

  return {
    handleSubscriptions,
    handleEmailSubscriptions,
    handleUnsubscribe,
    snapshotsInfo,
    currentFrequency,
    setCurrentFrequency,
    email,
    setEmail,
    emailValidated,
    setEmailValidated,
    sentEmail,
    setSentEmail,
    bundledSubs,
    chainEventSubs,
    relevantSubscribedCommunities,
    toggleAllInAppNotifications,
  };
};

export default useNotificationSettings;

1	import { NotificationCategories } from '@hicommonwealth/shared';
2	import { getMultipleSpacesById } from 'helpers/snapshot_utils';
3	import useForceRerender from 'hooks/useForceRerender';
4	import 'pages/notification_settings/index.scss';
5	import { useEffect, useState } from 'react';
6	import app from 'state';
7	import useUserStore from 'state/ui/user';
8	import NotificationSubscription from '../../../models/NotificationSubscription';
9	import { bundleSubs, extractSnapshotProposals } from './helpers';
10
11	export type SnapshotInfo = {
12	snapshotId: string;
13	space: {
14	avatar: string;
15	name: string;
16	};
17	subs: Array<NotificationSubscription>;
18	};
19
20	const useNotificationSettings = () => {	×
21	const forceRerender = useForceRerender();	×
22	const [email, setEmail] = useState('');	×
23	const [emailValidated, setEmailValidated] = useState(false);	×
24	const [sentEmail, setSentEmail] = useState(false);	×
25	const [snapshotsInfo, setSnapshotsInfo] = useState(null);	×
26
27	const user = useUserStore();	×
28
29	const [currentFrequency, setCurrentFrequency] = useState(	×
30	user.emailNotificationInterval,
31	);
32
33	useEffect(() => {	×
34	app.user.notifications.isLoaded.once('redraw', forceRerender);	×
35	}, [forceRerender]);
36
37	useEffect(() => {	×
38	// bundled snapshot subscriptions
39	const bundledSnapshotSubs = extractSnapshotProposals(	×
40	app.user.notifications.discussionSubscriptions,
41	);
42	const snapshotIds = Object.keys(bundledSnapshotSubs);	×
43
44	const getSpaces = async () => {	×
45	try {	×
46	const getSpaceById = await getMultipleSpacesById(snapshotIds);	×
47
48	const snapshotsInfoArr = snapshotIds.map((snapshotId) => ({	×
49	snapshotId,
50	space: getSpaceById.find((x: { id: string }) => x.id === snapshotId),	×
51	subs: bundledSnapshotSubs[snapshotId],
52	}));
53
54	// @ts-expect-error StrictNullChecks
55	setSnapshotsInfo(snapshotsInfoArr);	×
56	} catch (err) {
57	console.error(err);	×
58	return null;	×
59	}
60	};
61
62	getSpaces().catch(console.error);	×
63	}, []);
64
65	const handleSubscriptions = async (	×
66	hasSomeInAppSubs: boolean,
67	subs: NotificationSubscription[],
68	) => {
69	if (hasSomeInAppSubs) {	×
70	await app.user.notifications.disableSubscriptions(subs);	×
71	} else {
72	await app.user.notifications.enableSubscriptions(subs);	×
73	}
74	forceRerender();	×
75	};
76
77	const handleEmailSubscriptions = async (	×
78	hasSomeEmailSubs: boolean,
79	subs: NotificationSubscription[],
80	) => {
81	if (hasSomeEmailSubs) {	×
82	await app.user.notifications.disableImmediateEmails(subs);	×
83	} else {
84	await app.user.notifications.enableImmediateEmails(subs);	×
85	}
86	forceRerender();	×
87	};
88
89	const handleUnsubscribe = async (subscription: NotificationSubscription) => {	×
90	await app.user.notifications.deleteSubscription(subscription);	×
91	forceRerender();	×
92	};
93
94	// bundled discussion subscriptions
95	const bundledSubs = bundleSubs(	×
96	app?.user.notifications.discussionSubscriptions,
97	);
98
99	// bundled chain-event subscriptions
100	const chainEventSubs = bundleSubs(	×
101	app?.user.notifications.chainEventSubscriptions,
102	);
103
104	const subscribedCommunityIds =
105	app?.user.notifications.chainEventSubscribedChainIds;	×
106
107	// communities the user has addresses for but does not have existing subscriptions for
108	const relevantSubscribedCommunities = user.addresses	×
109	?.map?.((x) => x?.community)	×
110	?.filter?.(
111	(x) =>
112	subscribedCommunityIds?.includes?.(x?.id) && !chainEventSubs?.[x?.id],	×
113	);
114
115	const toggleAllInAppNotifications = async (enableAll: boolean) => {	×
116	const subIds = [];	×
117
118	// get all subscription ids
119	// eslint-disable-next-line @typescript-eslint/no-unused-vars
UNCOV 120	Object.entries(chainEventSubs).map(([_, subs]) =>	×
121	// @ts-expect-error StrictNullChecks
122	subIds.push(...(subs \|\| [])),	×
123	);
124	// eslint-disable-next-line @typescript-eslint/no-unused-vars
UNCOV 125	Object.entries(bundledSubs).map(([_, subs]) =>	×
126	// @ts-expect-error StrictNullChecks
127	subIds.push(...(subs \|\| [])),	×
128	);
129	// @ts-expect-error StrictNullChecks
130	snapshotsInfo?.map(({ snapshotId, subs }: SnapshotInfo) => {	×
131	// @ts-expect-error StrictNullChecks
132	if (snapshotId) subIds.push(...(subs \|\| []));	×
133	});
134
135	// enable/disable all subscriptions
136	await handleSubscriptions(!enableAll, subIds);	×
137	await handleEmailSubscriptions(!enableAll, subIds);	×
138	if (enableAll) {	×
139	relevantSubscribedCommunities	×
140	.sort((x, y) => x.name.localeCompare(y.name))	×
141	.map((community) => {
142	app.user.notifications	×
143	.subscribe({
144	categoryId: NotificationCategories.ChainEvent,
145	options: { communityId: community.id },
146	})
147	.catch(console.error);
148	});
149	}
150	};
151
152	return {	×
153	handleSubscriptions,
154	handleEmailSubscriptions,
155	handleUnsubscribe,
156	snapshotsInfo,
157	currentFrequency,
158	setCurrentFrequency,
159	email,
160	setEmail,
161	emailValidated,
162	setEmailValidated,
163	sentEmail,
164	setSentEmail,
165	bundledSubs,
166	chainEventSubs,
167	relevantSubscribedCommunities,
168	toggleAllInAppNotifications,
169	};
170	};
171
172	export default useNotificationSettings;

hicommonwealth / commonwealth / 10394257115

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