9600536876

Committed 20 Jun 2024 03:50PM UTC coverage: 1.156% (-14.0%) from 15.137%

Build # 9600536876

Build Type

Pull #7910

github

Committed by

web-flow

Commit Message

Merge 50d4cef7b into 2c4ea3afa

Pull Request Pull Request #7910: Implements subscriptions and community alerts page.

Run Details

169 of 18098 branches covered (0.93%)

Branch coverage included in aggregate %.

0 of 82 new or added lines in 8 files covered. (0.0%)

3318 existing lines in 320 files now uncovered.

394 of 30589 relevant lines covered (1.29%)

0.04 hits per line

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

0.0

/packages/commonwealth/client/scripts/controllers/server/notifications.ts

/* eslint-disable no-restricted-syntax */
import axios from 'axios';
import { EventEmitter } from 'events';

import NotificationSubscription, {
  modelFromServer,
} from 'models/NotificationSubscription';

import app from 'state';

import { Subscription } from '@hicommonwealth/schemas';
import { NotificationCategories } from '@hicommonwealth/shared';
import { findSubscription, SubUniqueData } from 'helpers/findSubscription';
import { NotificationStore } from 'stores';
import { z } from 'zod';
import Notification from '../../models/Notification';

const post = async (route, args, callback) => {
  try {
    args['jwt'] = app.user.jwt;
    const response = await axios.post(app.serverUrl() + route, args);

    if (response.data.status === 'Success') {
      callback(response.data.result);
    } else {
      console.error(response.data);
    }
  } catch (error) {
    console.error(error);
  }
};

const get = async (route, args, callback) => {
  try {
    args['jwt'] = app.user.jwt;
    const response = await axios.get(app.serverUrl() + route, { params: args });

    if (response.data.status === 'Success') {
      callback(response.data.result);
    } else {
      console.error(response.data);
    }
  } catch (error) {
    console.error(error);
  }
};

interface NotifOptions {
  community_filter: string;
  maxId: number;
}

class NotificationsController {
  private _discussionStore: NotificationStore = new NotificationStore();
  private _chainEventStore: NotificationStore = new NotificationStore();
  // these are the chains that chain-events has active listeners for (used to detemine what chains are shown on the
  // notification settings page
  private _chainEventSubscribedChainIds: string[] = [];

  private _numPages = 0;
  private _numUnread = 0;

  public isLoaded = new EventEmitter();
  public isUpdated = new EventEmitter();

  public get chainEventSubscribedChainIds(): string[] {
    return this._chainEventSubscribedChainIds;
  }

  public get numPages(): number {
    return this._numPages;
  }

  public get numUnread(): number {
    return this._numUnread;
  }

  public get discussionNotifications(): Notification[] {
    return this._discussionStore.getAll();
  }

  public get chainEventNotifications(): Notification[] {
    return this._chainEventStore.getAll();
  }

  public get allNotifications(): Notification[] {
    return this._discussionStore
      .getAll()
      .concat(this._chainEventStore.getAll());
  }

  private _subscriptions: NotificationSubscription[] = [];

  public get discussionSubscriptions(): NotificationSubscription[] {
    return this._subscriptions.filter(
      (s) => s.categoryId !== NotificationCategories.ChainEvent,
    );
  }

  public get chainEventSubscriptions(): NotificationSubscription[] {
    return this._subscriptions.filter(
      (s) => s.categoryId === NotificationCategories.ChainEvent,
    );
  }

  public subscribe(data: SubUniqueData) {
    const subscription = this.findNotificationSubscription(data);
    if (subscription) {
      return this.enableSubscriptions([subscription]);
    } else {
      const untypedData: {
        categoryId: NotificationCategories;
        options?: {
          communityId?: string;
          threadId?: number;
          commentId?: number;
          snapshotId?: string;
        };
      } = data;
      const requestData = {
        community_id: untypedData.options?.communityId,
        thread_id: untypedData.options?.threadId,
        comment_id: untypedData.options?.commentId,
        snapshot_id: untypedData.options?.snapshotId,
      };

      return post(
        '/createSubscription',
        {
          category: data.categoryId,
          is_active: true,
          ...requestData,
        },
        (result: z.infer<typeof Subscription>) => {
          const newSubscription = modelFromServer(result);
          this._subscriptions.push(newSubscription);
        },
      );
    }
  }

  public enableSubscriptions(subscriptions: NotificationSubscription[]) {
    // TODO: Change to PUT /subscriptions
    return post(
      '/enableSubscriptions',
      {
        'subscription_ids[]': subscriptions.map((n) => n.id),
      },
      () => {
        for (const s of subscriptions) {
          s.enable();
        }
      },
    );
  }

  public disableSubscriptions(subscriptions: NotificationSubscription[]) {
    // TODO: Change to PUT /subscriptions
    return post(
      '/disableSubscriptions',
      {
        'subscription_ids[]': subscriptions.map((n) => n.id),
      },
      () => {
        const ceSubs = [];
        for (const s of subscriptions) {
          s.disable();
          // @ts-expect-error StrictNullChecks
          if (s.category === 'chain-event') ceSubs.push(s);
        }
      },
    );
  }

  public enableImmediateEmails(subscriptions: NotificationSubscription[]) {
    // TODO: Change to PUT /immediateEmails
    return post(
      '/enableImmediateEmails',
      {
        'subscription_ids[]': subscriptions.map((n) => n.id),
      },
      () => {
        for (const s of subscriptions) {
          s.enableImmediateEmail();
        }
      },
    );
  }

  public disableImmediateEmails(subscriptions: NotificationSubscription[]) {
    // TODO: Change to PUT /immediateEmails
    return post(
      '/disableImmediateEmails',
      {
        'subscription_ids[]': subscriptions.map((n) => n.id),
      },
      () => {
        for (const s of subscriptions) {
          s.disableImmediateEmail();
        }
      },
    );
  }

  public deleteSubscription(subscription: NotificationSubscription) {
    // TODO: Change to DELETE /subscription
    return post(
      '/deleteSubscription',
      {
        subscription_id: subscription.id,
      },
      () => {
        const idx = this._subscriptions.indexOf(subscription);
        if (idx === -1) {
          throw new Error('subscription not found!');
        }
        this._subscriptions.splice(idx, 1);
      },
    );
  }

  public markAsRead(notifications: Notification[]) {
    // TODO: Change to PUT /notificationsRead
    const MAX_NOTIFICATIONS_READ = 100; // mark up to 100 notifications read at a time
    const unreadNotifications = notifications.filter((notif) => !notif.isRead);
    if (unreadNotifications.length === 0) {
      return Promise.resolve();
    }

    return post(
      '/markNotificationsRead',
      {
        'notification_ids[]': unreadNotifications
          .slice(0, MAX_NOTIFICATIONS_READ)
          .map((n) => n.id),
      },
      () => {
        for (const n of unreadNotifications.slice(0, MAX_NOTIFICATIONS_READ)) {
          n.markRead();
        }
        if (unreadNotifications.slice(MAX_NOTIFICATIONS_READ).length > 0) {
          this.markAsRead(unreadNotifications.slice(MAX_NOTIFICATIONS_READ));
        }
      },
    );
  }

  public clearAllRead() {
    return post('/clearReadNotifications', {}, () => {
      const toClear = this.allNotifications.filter((n) => n.isRead);
      for (const n of toClear) {
        this.removeFromStore(n);
      }
    });
  }

  public clear() {
    this._discussionStore.clear();
    this._chainEventStore.clear();
  }

  public removeFromStore(n) {
    if (n.chainEvent) this._chainEventStore.remove(n);
    else this._discussionStore.remove(n);
  }

  public delete(notifications: Notification[]) {
    // TODO: Change to PUT /clearNotifications
    const MAX_NOTIFICATIONS_CLEAR = 100; // delete up to 100 notifications at a time

    if (notifications.length === 0) return;
    return post(
      '/clearNotifications',
      {
        'notification_ids[]': notifications
          .slice(0, MAX_NOTIFICATIONS_CLEAR)
          .map((n) => n.id),
      },
      async () => {
        notifications
          .slice(0, MAX_NOTIFICATIONS_CLEAR)
          .map((n) => this.removeFromStore(n));
        if (notifications.slice(MAX_NOTIFICATIONS_CLEAR).length > 0) {
          this.delete(notifications.slice(MAX_NOTIFICATIONS_CLEAR));
        }
        // TODO: post(/clearNotifications) should wait on all notifications being marked as read before redrawing
      },
    );
  }

  public update(n: Notification) {
    if (n.chainEvent && !this._chainEventStore.getById(n.id)) {
      this._chainEventStore.add(n);
      this.isUpdated.emit('redraw');
    } else if (!n.chainEvent && !this._discussionStore.getById(n.id)) {
      this._discussionStore.add(n);
      this.isUpdated.emit('redraw');
    }
  }

  public clearSubscriptions() {
    this._subscriptions = [];
  }

  public sortNotificationsStore(storeType: string) {
    if (storeType == 'chain-events') {
      const unsortedNotifications = this.chainEventNotifications;
      this._chainEventStore.clear();
      unsortedNotifications.sort((a, b) => b.id - a.id);
      for (const notif of unsortedNotifications)
        this._chainEventStore.add(notif);
    } else {
      const unsortedNotifications = this.discussionNotifications;
      this._discussionStore.clear();
      unsortedNotifications.sort((a, b) => b.id - a.id);
      for (const notif of unsortedNotifications)
        this._discussionStore.add(notif);
    }
  }

  public getChainEventNotifications() {
    if (!app.user || !app.user.jwt) {
      throw new Error('must be signed in to refresh notifications');
    }

    // @ts-expect-error StrictNullChecks
    const options: NotifOptions = app.isCustomDomain()
      ? { community_filter: app.activeChainId(), maxId: undefined }
      : { community_filter: undefined, maxId: undefined };

    return post('/viewChainEventNotifications', options, (result) => {
      this._numPages = result.numPages;
      this._numUnread = result.numUnread;
      this.parseNotifications(result.subscriptions);
      this.sortNotificationsStore('chain-events');
    });
  }

  public getDiscussionNotifications() {
    if (!app.user || !app.user.jwt) {
      throw new Error('must be signed in to refresh notifications');
    }
    // @ts-expect-error StrictNullChecks
    const options: NotifOptions = app.isCustomDomain()
      ? { community_filter: app.activeChainId(), maxId: undefined }
      : { community_filter: undefined, maxId: undefined };

    return post('/viewDiscussionNotifications', options, (result) => {
      this._numPages = result.numPages;
      this._numUnread = result.numUnread;
      this.parseNotifications(result.subscriptions);
      this.sortNotificationsStore('discussion');
    });
  }

  private parseNotifications(subscriptions) {
    for (const subscriptionJSON of subscriptions) {
      const subscriptionId = subscriptionJSON.subscription_id;
      const categoryId = subscriptionJSON.category_id;

      // save the notification read + notification instances if any
      for (const notificationsReadJSON of subscriptionJSON.NotificationsReads) {
        const data = {
          is_read: notificationsReadJSON.is_read,
          subscription_id: subscriptionId,
          ...notificationsReadJSON.Notification,
        };
        const notification = Notification.fromJSON(data);

        if (categoryId === 'chain-event') {
          if (!this._chainEventStore.getById(notification.id))
            this._chainEventStore.add(notification);
        } else {
          if (!this._discussionStore.getById(notification.id))
            this._discussionStore.add(notification);
        }
      }
    }
  }

  public getSubscriptions() {
    return get('/viewSubscriptions', {}, (result) => {
      this._subscriptions = [];

      const subs = result;
      subs.forEach((sub) => this._subscriptions.push(modelFromServer(sub)));
    });
  }

  public getSubscribedChains() {
    return post('/getSubscribedCommunities', {}, (result) => {
      this._chainEventSubscribedChainIds = result.map((x) => x.id);
    });
  }

  public async refresh() {
    await Promise.all([
      this.getDiscussionNotifications(),
      this.getChainEventNotifications(),
      this.getSubscriptions(),
      this.getSubscribedChains(),
    ]);
    this.isLoaded.emit('redraw');
    return Promise.resolve();
  }

  public findNotificationSubscription(findOptions: SubUniqueData) {
    return findSubscription(findOptions, this._subscriptions);
  }
}

export default NotificationsController;

1	/* eslint-disable no-restricted-syntax */
2	import axios from 'axios';
3	import { EventEmitter } from 'events';
4
5	import NotificationSubscription, {
6	modelFromServer,
7	} from 'models/NotificationSubscription';
8
9	import app from 'state';
10
11	import { Subscription } from '@hicommonwealth/schemas';
12	import { NotificationCategories } from '@hicommonwealth/shared';
13	import { findSubscription, SubUniqueData } from 'helpers/findSubscription';
14	import { NotificationStore } from 'stores';
15	import { z } from 'zod';
16	import Notification from '../../models/Notification';
17
UNCOV 18	const post = async (route, args, callback) => {	×
19	try {	×
20	args['jwt'] = app.user.jwt;	×
21	const response = await axios.post(app.serverUrl() + route, args);	×
22
23	if (response.data.status === 'Success') {	×
24	callback(response.data.result);	×
25	} else {
26	console.error(response.data);	×
27	}
28	} catch (error) {
29	console.error(error);	×
30	}
31	};
32
UNCOV 33	const get = async (route, args, callback) => {	×
34	try {	×
35	args['jwt'] = app.user.jwt;	×
36	const response = await axios.get(app.serverUrl() + route, { params: args });	×
37
38	if (response.data.status === 'Success') {	×
39	callback(response.data.result);	×
40	} else {
41	console.error(response.data);	×
42	}
43	} catch (error) {
44	console.error(error);	×
45	}
46	};
47
48	interface NotifOptions {
49	community_filter: string;
50	maxId: number;
51	}
52
53	class NotificationsController {
UNCOV 54	private _discussionStore: NotificationStore = new NotificationStore();	×
UNCOV 55	private _chainEventStore: NotificationStore = new NotificationStore();	×
56	// these are the chains that chain-events has active listeners for (used to detemine what chains are shown on the
57	// notification settings page
UNCOV 58	private _chainEventSubscribedChainIds: string[] = [];	×
59
UNCOV 60	private _numPages = 0;	×
UNCOV 61	private _numUnread = 0;	×
62
UNCOV 63	public isLoaded = new EventEmitter();	×
UNCOV 64	public isUpdated = new EventEmitter();	×
65
66	public get chainEventSubscribedChainIds(): string[] {
67	return this._chainEventSubscribedChainIds;	×
68	}
69
70	public get numPages(): number {
71	return this._numPages;	×
72	}
73
74	public get numUnread(): number {
75	return this._numUnread;	×
76	}
77
78	public get discussionNotifications(): Notification[] {
79	return this._discussionStore.getAll();	×
80	}
81
82	public get chainEventNotifications(): Notification[] {
83	return this._chainEventStore.getAll();	×
84	}
85
86	public get allNotifications(): Notification[] {
87	return this._discussionStore	×
88	.getAll()
89	.concat(this._chainEventStore.getAll());
90	}
91
UNCOV 92	private _subscriptions: NotificationSubscription[] = [];	×
93
94	public get discussionSubscriptions(): NotificationSubscription[] {
95	return this._subscriptions.filter(	×
96	(s) => s.categoryId !== NotificationCategories.ChainEvent,	×
97	);
98	}
99
100	public get chainEventSubscriptions(): NotificationSubscription[] {
101	return this._subscriptions.filter(	×
102	(s) => s.categoryId === NotificationCategories.ChainEvent,	×
103	);
104	}
105
106	public subscribe(data: SubUniqueData) {
107	const subscription = this.findNotificationSubscription(data);	×
108	if (subscription) {	×
109	return this.enableSubscriptions([subscription]);	×
110	} else {
111	const untypedData: {
112	categoryId: NotificationCategories;
113	options?: {
114	communityId?: string;
115	threadId?: number;
116	commentId?: number;
117	snapshotId?: string;
118	};
119	} = data;	×
120	const requestData = {	×
121	community_id: untypedData.options?.communityId,
122	thread_id: untypedData.options?.threadId,
123	comment_id: untypedData.options?.commentId,
124	snapshot_id: untypedData.options?.snapshotId,
125	};
126
127	return post(	×
128	'/createSubscription',
129	{
130	category: data.categoryId,
131	is_active: true,
132	...requestData,
133	},
134	(result: z.infer<typeof Subscription>) => {
135	const newSubscription = modelFromServer(result);	×
136	this._subscriptions.push(newSubscription);	×
137	},
138	);
139	}
140	}
141
142	public enableSubscriptions(subscriptions: NotificationSubscription[]) {
143	// TODO: Change to PUT /subscriptions
144	return post(	×
145	'/enableSubscriptions',
146	{
147	'subscription_ids[]': subscriptions.map((n) => n.id),	×
148	},
149	() => {
150	for (const s of subscriptions) {	×
151	s.enable();	×
152	}
153	},
154	);
155	}
156
157	public disableSubscriptions(subscriptions: NotificationSubscription[]) {
158	// TODO: Change to PUT /subscriptions
159	return post(	×
160	'/disableSubscriptions',
161	{
162	'subscription_ids[]': subscriptions.map((n) => n.id),	×
163	},
164	() => {
165	const ceSubs = [];	×
166	for (const s of subscriptions) {	×
167	s.disable();	×
168	// @ts-expect-error StrictNullChecks
169	if (s.category === 'chain-event') ceSubs.push(s);	×
170	}
171	},
172	);
173	}
174
175	public enableImmediateEmails(subscriptions: NotificationSubscription[]) {
176	// TODO: Change to PUT /immediateEmails
177	return post(	×
178	'/enableImmediateEmails',
179	{
180	'subscription_ids[]': subscriptions.map((n) => n.id),	×
181	},
182	() => {
183	for (const s of subscriptions) {	×
184	s.enableImmediateEmail();	×
185	}
186	},
187	);
188	}
189
190	public disableImmediateEmails(subscriptions: NotificationSubscription[]) {
191	// TODO: Change to PUT /immediateEmails
192	return post(	×
193	'/disableImmediateEmails',
194	{
195	'subscription_ids[]': subscriptions.map((n) => n.id),	×
196	},
197	() => {
198	for (const s of subscriptions) {	×
199	s.disableImmediateEmail();	×
200	}
201	},
202	);
203	}
204
205	public deleteSubscription(subscription: NotificationSubscription) {
206	// TODO: Change to DELETE /subscription
207	return post(	×
208	'/deleteSubscription',
209	{
210	subscription_id: subscription.id,
211	},
212	() => {
213	const idx = this._subscriptions.indexOf(subscription);	×
214	if (idx === -1) {	×
215	throw new Error('subscription not found!');	×
216	}
217	this._subscriptions.splice(idx, 1);	×
218	},
219	);
220	}
221
222	public markAsRead(notifications: Notification[]) {
223	// TODO: Change to PUT /notificationsRead
224	const MAX_NOTIFICATIONS_READ = 100; // mark up to 100 notifications read at a time	×
225	const unreadNotifications = notifications.filter((notif) => !notif.isRead);	×
226	if (unreadNotifications.length === 0) {	×
227	return Promise.resolve();	×
228	}
229
230	return post(	×
231	'/markNotificationsRead',
232	{
233	'notification_ids[]': unreadNotifications
234	.slice(0, MAX_NOTIFICATIONS_READ)
235	.map((n) => n.id),	×
236	},
237	() => {
238	for (const n of unreadNotifications.slice(0, MAX_NOTIFICATIONS_READ)) {	×
239	n.markRead();	×
240	}
241	if (unreadNotifications.slice(MAX_NOTIFICATIONS_READ).length > 0) {	×
242	this.markAsRead(unreadNotifications.slice(MAX_NOTIFICATIONS_READ));	×
243	}
244	},
245	);
246	}
247
248	public clearAllRead() {
249	return post('/clearReadNotifications', {}, () => {	×
250	const toClear = this.allNotifications.filter((n) => n.isRead);	×
251	for (const n of toClear) {	×
252	this.removeFromStore(n);	×
253	}
254	});
255	}
256
257	public clear() {
258	this._discussionStore.clear();	×
259	this._chainEventStore.clear();	×
260	}
261
262	public removeFromStore(n) {
263	if (n.chainEvent) this._chainEventStore.remove(n);	×
264	else this._discussionStore.remove(n);	×
265	}
266
267	public delete(notifications: Notification[]) {
268	// TODO: Change to PUT /clearNotifications
269	const MAX_NOTIFICATIONS_CLEAR = 100; // delete up to 100 notifications at a time	×
270
271	if (notifications.length === 0) return;	×
272	return post(	×
273	'/clearNotifications',
274	{
275	'notification_ids[]': notifications
276	.slice(0, MAX_NOTIFICATIONS_CLEAR)
277	.map((n) => n.id),	×
278	},
279	async () => {
280	notifications	×
281	.slice(0, MAX_NOTIFICATIONS_CLEAR)
282	.map((n) => this.removeFromStore(n));	×
283	if (notifications.slice(MAX_NOTIFICATIONS_CLEAR).length > 0) {	×
284	this.delete(notifications.slice(MAX_NOTIFICATIONS_CLEAR));	×
285	}
286	// TODO: post(/clearNotifications) should wait on all notifications being marked as read before redrawing
287	},
288	);
289	}
290
291	public update(n: Notification) {
292	if (n.chainEvent && !this._chainEventStore.getById(n.id)) {	×
293	this._chainEventStore.add(n);	×
294	this.isUpdated.emit('redraw');	×
295	} else if (!n.chainEvent && !this._discussionStore.getById(n.id)) {	×
296	this._discussionStore.add(n);	×
297	this.isUpdated.emit('redraw');	×
298	}
299	}
300
301	public clearSubscriptions() {
302	this._subscriptions = [];	×
303	}
304
305	public sortNotificationsStore(storeType: string) {
306	if (storeType == 'chain-events') {	×
307	const unsortedNotifications = this.chainEventNotifications;	×
308	this._chainEventStore.clear();	×
309	unsortedNotifications.sort((a, b) => b.id - a.id);	×
310	for (const notif of unsortedNotifications)	×
311	this._chainEventStore.add(notif);	×
312	} else {
313	const unsortedNotifications = this.discussionNotifications;	×
314	this._discussionStore.clear();	×
315	unsortedNotifications.sort((a, b) => b.id - a.id);	×
316	for (const notif of unsortedNotifications)	×
317	this._discussionStore.add(notif);	×
318	}
319	}
320
321	public getChainEventNotifications() {
322	if (!app.user \|\| !app.user.jwt) {	×
323	throw new Error('must be signed in to refresh notifications');	×
324	}
325
326	// @ts-expect-error StrictNullChecks
327	const options: NotifOptions = app.isCustomDomain()	×
328	? { community_filter: app.activeChainId(), maxId: undefined }
329	: { community_filter: undefined, maxId: undefined };
330
331	return post('/viewChainEventNotifications', options, (result) => {	×
332	this._numPages = result.numPages;	×
333	this._numUnread = result.numUnread;	×
334	this.parseNotifications(result.subscriptions);	×
335	this.sortNotificationsStore('chain-events');	×
336	});
337	}
338
339	public getDiscussionNotifications() {
340	if (!app.user \|\| !app.user.jwt) {	×
341	throw new Error('must be signed in to refresh notifications');	×
342	}
343	// @ts-expect-error StrictNullChecks
344	const options: NotifOptions = app.isCustomDomain()	×
345	? { community_filter: app.activeChainId(), maxId: undefined }
346	: { community_filter: undefined, maxId: undefined };
347
348	return post('/viewDiscussionNotifications', options, (result) => {	×
349	this._numPages = result.numPages;	×
350	this._numUnread = result.numUnread;	×
351	this.parseNotifications(result.subscriptions);	×
352	this.sortNotificationsStore('discussion');	×
353	});
354	}
355
356	private parseNotifications(subscriptions) {
357	for (const subscriptionJSON of subscriptions) {	×
358	const subscriptionId = subscriptionJSON.subscription_id;	×
359	const categoryId = subscriptionJSON.category_id;	×
360
361	// save the notification read + notification instances if any
362	for (const notificationsReadJSON of subscriptionJSON.NotificationsReads) {	×
363	const data = {	×
364	is_read: notificationsReadJSON.is_read,
365	subscription_id: subscriptionId,
366	...notificationsReadJSON.Notification,
367	};
368	const notification = Notification.fromJSON(data);	×
369
370	if (categoryId === 'chain-event') {	×
371	if (!this._chainEventStore.getById(notification.id))	×
372	this._chainEventStore.add(notification);	×
373	} else {
374	if (!this._discussionStore.getById(notification.id))	×
375	this._discussionStore.add(notification);	×
376	}
377	}
378	}
379	}
380
381	public getSubscriptions() {
382	return get('/viewSubscriptions', {}, (result) => {	×
383	this._subscriptions = [];	×
384
385	const subs = result;	×
386	subs.forEach((sub) => this._subscriptions.push(modelFromServer(sub)));	×
387	});
388	}
389
390	public getSubscribedChains() {
391	return post('/getSubscribedCommunities', {}, (result) => {	×
392	this._chainEventSubscribedChainIds = result.map((x) => x.id);	×
393	});
394	}
395
396	public async refresh() {
397	await Promise.all([	×
398	this.getDiscussionNotifications(),
399	this.getChainEventNotifications(),
400	this.getSubscriptions(),
401	this.getSubscribedChains(),
402	]);
403	this.isLoaded.emit('redraw');	×
404	return Promise.resolve();	×
405	}
406
407	public findNotificationSubscription(findOptions: SubUniqueData) {
408	return findSubscription(findOptions, this._subscriptions);	×
409	}
410	}
411
412	export default NotificationsController;

hicommonwealth / commonwealth / 9600536876

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