9689702527

Committed 27 Jun 2024 02:25AM UTC coverage: 14.619% (+14.3%) from 0.359%

Build # 9689702527

Build Type

Pull #8210

github

Committed by

web-flow

Commit Message

Merge f7896faf9 into 4b0cef8c2

Pull Request Pull Request #8210: Fixes for session keys after v0.10 Canvas upgrade

Run Details

3550 of 23082 branches covered (15.38%)

Branch coverage included in aggregate %.

13 of 31 new or added lines in 9 files covered. (41.94%)

52 existing lines in 7 files now uncovered.

4891 of 34657 relevant lines covered (14.11%)

4.71 hits per line

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

78.42

/packages/commonwealth/server/util/emitNotifications.ts

/* eslint-disable max-len */
import { logger, stats } from '@hicommonwealth/core';
import { type DB, type NotificationInstance } from '@hicommonwealth/model';
import {
  IChainEventNotificationData,
  IForumNotificationData,
  NotificationCategories,
  NotificationDataAndCategory,
} from '@hicommonwealth/shared';
import Sequelize, { QueryTypes } from 'sequelize';
import { fileURLToPath } from 'url';
import { config } from '../config';
import { mapNotificationsDataToSubscriptions } from './subscriptionMapping';
import { dispatchWebhooks } from './webhooks/dispatchWebhook';

const __filename = fileURLToPath(import.meta.url);
const log = logger(__filename);

const { Op } = Sequelize;

export default async function emitNotifications(
  models: DB,
  notification_data_and_category: NotificationDataAndCategory,
  excludeAddresses?: string[],
  includeAddresses?: string[],
): Promise<NotificationInstance> {
  const notification_data = notification_data_and_category.data;
  const category_id = notification_data_and_category.categoryId;
  // get subscribers to send notifications to
  stats().increment('cw.notifications.created', {
    category_id,
    chain:
      (notification_data as any).chain || (notification_data as any).chain_id,
  });

  const uniqueOptions = mapNotificationsDataToSubscriptions(
    notification_data_and_category,
  );
  const findOptions: any = {
    [Op.and]: [{ category_id }, { ...uniqueOptions }, { is_active: true }],
  };

  // typeguard function to differentiate between chain event notifications as needed
  let chainEvent: IChainEventNotificationData;
  const isChainEventData = category_id === NotificationCategories.ChainEvent;

  if (isChainEventData) {
    chainEvent = <IChainEventNotificationData>notification_data;
  }

  // retrieve distinct user ids given a set of addresses
  const fetchUsersFromAddresses = async (
    addresses: string[],
  ): Promise<number[]> => {
    // fetch user ids from address models
    const addressModels = await models.Address.findAll({
      where: {
        address: {
          [Op.in]: addresses,
        },
      },
    });
    if (addressModels && addressModels.length > 0) {
      const userIds = addressModels.map((a) => a.user_id);

      // remove duplicates and null user_ids
      const userIdsDedup = userIds.filter(
        (a, b) => userIds.indexOf(a) === b && a !== null,
      );
      // @ts-expect-error StrictNullChecks
      return userIdsDedup;
    } else {
      return [];
    }
  };

  // currently excludes override includes, but we may want to provide the option for both
  if (excludeAddresses && excludeAddresses.length > 0) {
    const ids = await fetchUsersFromAddresses(excludeAddresses);
    if (ids && ids.length > 0) {
      findOptions[Op.and].push({ subscriber_id: { [Op.notIn]: ids } });
    }
  } else if (includeAddresses && includeAddresses.length > 0) {
    const ids = await fetchUsersFromAddresses(includeAddresses);
    if (ids && ids.length > 0) {
      findOptions[Op.and].push({ subscriber_id: { [Op.in]: ids } });
    }
  }

  // get all relevant subscriptions
  const subscriptions = await models.Subscription.findAll({
    where: findOptions,
    include: models.User,
  });

  // get notification if it already exists
  let notification: NotificationInstance;
  // @ts-expect-error StrictNullChecks
  if (isChainEventData && chainEvent.id) {
    // @ts-expect-error StrictNullChecks
    notification = await models.Notification.findOne({
      where: {
        // @ts-expect-error StrictNullChecks
        chain_event_id: chainEvent.id,
      },
    });
  } else {
    // @ts-expect-error StrictNullChecks
    notification = await models.Notification.findOne({
      where: {
        notification_data: JSON.stringify(notification_data),
      },
    });
  }

  // if the notification does not yet exist create it here
  if (!notification) {
    if (isChainEventData) {
      // @ts-expect-error StrictNullChecks
      notification = await models.Notification.create({
        // @ts-expect-error StrictNullChecks
        notification_data: JSON.stringify(chainEvent),
        // @ts-expect-error StrictNullChecks
        chain_event_id: chainEvent.id,
        category_id: 'chain-event',
        // @ts-expect-error StrictNullChecks
        community_id: chainEvent.community_id,
      });
    } else {
      // @ts-expect-error StrictNullChecks
      notification = await models.Notification.create({
        notification_data: JSON.stringify(notification_data),
        category_id,
        community_id: (<IForumNotificationData>notification_data).community_id,
        thread_id:
          Number((<IForumNotificationData>notification_data).thread_id) ||
          undefined,
      });
    }
  }

  let query = `INSERT INTO "NotificationsRead" (notification_id, subscription_id, is_read, user_id) VALUES `;
  const replacements = [];
  for (const subscription of subscriptions) {
    if (subscription.subscriber_id) {
      stats().increment('cw.notifications.emitted', {
        category_id,
        chain:
          (notification_data as any).chain ||
          (notification_data as any).chain_id,
        subscriber: `${subscription.subscriber_id}`,
      });
      query += `(?, ?, ?, ?), `;
      replacements.push(
        // @ts-expect-error StrictNullChecks
        notification.id,
        subscription.id,
        false,
        subscription.subscriber_id,
      );
    } else {
      // TODO: rollbar reported issue originates from here
      log.info(
        `Subscription: ${JSON.stringify(
          subscription.toJSON(),
        )}\nNotification_data: ${JSON.stringify(notification_data)}`,
      );
    }
  }
  if (replacements.length > 0) {
    query = query.slice(0, -2) + ';';
    await models.sequelize.query(query, {
      replacements,
      type: QueryTypes.INSERT,
    });
  }

  if (config.SEND_WEBHOOKS_EMAILS) {
    // webhooks
    try {
      await dispatchWebhooks(notification_data_and_category);
    } catch (e) {
      log.error('Failed to dispatch webhooks', e);
    }
  }

  return notification;
}

1	/* eslint-disable max-len */
2	import { logger, stats } from '@hicommonwealth/core';
3	import { type DB, type NotificationInstance } from '@hicommonwealth/model';
4	import {
5	IChainEventNotificationData,
6	IForumNotificationData,
7	NotificationCategories,
8	NotificationDataAndCategory,
9	} from '@hicommonwealth/shared';
10	import Sequelize, { QueryTypes } from 'sequelize';
11	import { fileURLToPath } from 'url';
12	import { config } from '../config';
13	import { mapNotificationsDataToSubscriptions } from './subscriptionMapping';
14	import { dispatchWebhooks } from './webhooks/dispatchWebhook';
15
16	const __filename = fileURLToPath(import.meta.url);	24✔
17	const log = logger(__filename);	24✔
18
19	const { Op } = Sequelize;	24✔
20
21	export default async function emitNotifications(
22	models: DB,
23	notification_data_and_category: NotificationDataAndCategory,
24	excludeAddresses?: string[],
25	includeAddresses?: string[],
26	): Promise<NotificationInstance> {
27	const notification_data = notification_data_and_category.data;	81✔
28	const category_id = notification_data_and_category.categoryId;	81✔
29	// get subscribers to send notifications to
30	stats().increment('cw.notifications.created', {	81✔
31	category_id,
32	chain:
33	(notification_data as any).chain \|\| (notification_data as any).chain_id,	324✔
34	});
35
36	const uniqueOptions = mapNotificationsDataToSubscriptions(	81✔
37	notification_data_and_category,
38	);
39	const findOptions: any = {	81✔
40	[Op.and]: [{ category_id }, { ...uniqueOptions }, { is_active: true }],
41	};
42
43	// typeguard function to differentiate between chain event notifications as needed
44	let chainEvent: IChainEventNotificationData;
45	const isChainEventData = category_id === NotificationCategories.ChainEvent;	81✔
46
47	if (isChainEventData) {	81✔
48	chainEvent = <IChainEventNotificationData>notification_data;	5✔
49	}
50
51	// retrieve distinct user ids given a set of addresses
52	const fetchUsersFromAddresses = async (	81✔
53	addresses: string[],
54	): Promise<number[]> => {
55	// fetch user ids from address models
56	const addressModels = await models.Address.findAll({	70✔
57	where: {
58	address: {
59	[Op.in]: addresses,
60	},
61	},
62	});
63	if (addressModels && addressModels.length > 0) {	70!
64	const userIds = addressModels.map((a) => a.user_id);	120✔
65
66	// remove duplicates and null user_ids
67	const userIdsDedup = userIds.filter(	70✔
68	(a, b) => userIds.indexOf(a) === b && a !== null,	120✔
69	);
70	// @ts-expect-error StrictNullChecks
71	return userIdsDedup;	70✔
72	} else {
UNCOV 73	return [];	×
74	}
75	};
76
77	// currently excludes override includes, but we may want to provide the option for both
78	if (excludeAddresses && excludeAddresses.length > 0) {	81✔
79	const ids = await fetchUsersFromAddresses(excludeAddresses);	70✔
80	if (ids && ids.length > 0) {	70!
81	findOptions[Op.and].push({ subscriber_id: { [Op.notIn]: ids } });	70✔
82	}
83	} else if (includeAddresses && includeAddresses.length > 0) {	11!
84	const ids = await fetchUsersFromAddresses(includeAddresses);	×
85	if (ids && ids.length > 0) {	×
UNCOV 86	findOptions[Op.and].push({ subscriber_id: { [Op.in]: ids } });	×
87	}
88	}
89
90	// get all relevant subscriptions
91	const subscriptions = await models.Subscription.findAll({	81✔
92	where: findOptions,
93	include: models.User,
94	});
95
96	// get notification if it already exists
97	let notification: NotificationInstance;
98	// @ts-expect-error StrictNullChecks
99	if (isChainEventData && chainEvent.id) {	81✔
100	// @ts-expect-error StrictNullChecks
101	notification = await models.Notification.findOne({	1✔
102	where: {
103	// @ts-expect-error StrictNullChecks
104	chain_event_id: chainEvent.id,
105	},
106	});
107	} else {
108	// @ts-expect-error StrictNullChecks
109	notification = await models.Notification.findOne({	80✔
110	where: {
111	notification_data: JSON.stringify(notification_data),
112	},
113	});
114	}
115
116	// if the notification does not yet exist create it here
117	if (!notification) {	81!
118	if (isChainEventData) {	81✔
119	// @ts-expect-error StrictNullChecks
120	notification = await models.Notification.create({	5✔
121	// @ts-expect-error StrictNullChecks
122	notification_data: JSON.stringify(chainEvent),
123	// @ts-expect-error StrictNullChecks
124	chain_event_id: chainEvent.id,
125	category_id: 'chain-event',
126	// @ts-expect-error StrictNullChecks
127	community_id: chainEvent.community_id,
128	});
129	} else {
130	// @ts-expect-error StrictNullChecks
131	notification = await models.Notification.create({	76✔
132	notification_data: JSON.stringify(notification_data),
133	category_id,
134	community_id: (<IForumNotificationData>notification_data).community_id,
135	thread_id:
136	Number((<IForumNotificationData>notification_data).thread_id) \|\|	154✔
137	undefined,
138	});
139	}
140	}
141
142	let query = `INSERT INTO "NotificationsRead" (notification_id, subscription_id, is_read, user_id) VALUES `;	80✔
143	const replacements = [];	80✔
144	for (const subscription of subscriptions) {	80✔
145	if (subscription.subscriber_id) {	13!
146	stats().increment('cw.notifications.emitted', {	13✔
147	category_id,
148	chain:
149	(notification_data as any).chain \|\|	52✔
150	(notification_data as any).chain_id,
151	subscriber: `${subscription.subscriber_id}`,
152	});
153	query += `(?, ?, ?, ?), `;	13✔
154	replacements.push(	13✔
155	// @ts-expect-error StrictNullChecks
156	notification.id,
157	subscription.id,
158	false,
159	subscription.subscriber_id,
160	);
161	} else {
162	// TODO: rollbar reported issue originates from here
163	log.info(	×
164	`Subscription: ${JSON.stringify(
165	subscription.toJSON(),
166	)}\nNotification_data: ${JSON.stringify(notification_data)}`,
167	);
168	}
169	}
170	if (replacements.length > 0) {	80✔
171	query = query.slice(0, -2) + ';';	11✔
172	await models.sequelize.query(query, {	11✔
173	replacements,
174	type: QueryTypes.INSERT,
175	});
176	}
177
178	if (config.SEND_WEBHOOKS_EMAILS) {	80!
179	// webhooks
UNCOV 180	try {	×
181	await dispatchWebhooks(notification_data_and_category);	×
182	} catch (e) {
UNCOV 183	log.error('Failed to dispatch webhooks', e);	×
184	}
185	}
186
187	return notification;	80✔
188	}

hicommonwealth / commonwealth / 9689702527

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