10907823301

Committed 17 Sep 2024 05:13PM UTC coverage: 13.507% (-0.2%) from 13.729%

Build # 10907823301

Build Type

Pull #9255

github

Committed by

web-flow

Commit Message

Merge e023a6617 into e48016d6c

Pull Request Pull Request #9255: Muhammad kaleem171.7111.blog link to clickable

Run Details

3009 of 20607 branches covered (14.6%)

Branch coverage included in aggregate %.

0 of 47 new or added lines in 4 files covered. (0.0%)

84 existing lines in 8 files now uncovered.

3900 of 30544 relevant lines covered (12.77%)

3.94 hits per line

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

61.25

/packages/commonwealth/server/workers/knock/eventHandlers/subscriptionPreferencesUpdated.ts

import {
  EventHandler,
  logger,
  notificationsProvider,
  RepeatFrequency,
  SubscriptionPreferencesUpdated,
  WorkflowKeys,
} from '@hicommonwealth/core';
import { models, SubscriptionPreferenceInstance } from '@hicommonwealth/model';
import { DaysOfWeek } from '@knocklabs/node';
import z from 'zod';
import { config } from '../../../config';

const log = logger(import.meta);

const output = z.boolean();

function mapDateToDaysOfWeek(
  date: Date,
): (typeof DaysOfWeek)[keyof typeof DaysOfWeek] {
  switch (date.getDay()) {
    case 0:
      return DaysOfWeek.Sun;
    case 1:
      return DaysOfWeek.Mon;
    case 2:
      return DaysOfWeek.Tue;
    case 3:
      return DaysOfWeek.Wed;
    case 4:
      return DaysOfWeek.Thu;
    case 5:
      return DaysOfWeek.Fri;
    default:
      return DaysOfWeek.Sat;
  }
}

async function createScheduleIfNotExists(
  workflowKey: WorkflowKeys.EmailRecap | WorkflowKeys.EmailDigest,
  userId: string,
): Promise<boolean> {
  const provider = notificationsProvider();

  const existingSchedules = await provider.getSchedules({
    user_id: userId,
    workflow_id: workflowKey,
  });

  if (existingSchedules.length === 0) {
    await provider.createSchedules({
      user_ids: [userId],
      workflow_id: workflowKey,
      schedule: [
        {
          frequency: RepeatFrequency.Weekly,
          days: [mapDateToDaysOfWeek(new Date())],
          hours: 12,
        },
      ],
    });
    return true;
  } else if (existingSchedules.length > 1) {
    log.error(
      `User ${userId} has more than 1 scheduled ${workflowKey} workflow run`,
      undefined,
      {
        userId,
        workflowKey,
        existingSchedules,
      },
    );
    return false;
  }

  return true;
}

async function deleteScheduleIfExists(
  workflowKey: WorkflowKeys.EmailRecap | WorkflowKeys.EmailDigest,
  userId: string,
): Promise<boolean> {
  const provider = notificationsProvider();

  const existingSchedules = await provider.getSchedules({
    user_id: userId,
    workflow_id: workflowKey,
  });

  if (existingSchedules.length === 0) return true;

  await provider.deleteSchedules({
    schedule_ids: existingSchedules.map((s) => s.id),
  });

  return true;
}

async function handleEmailPreferenceUpdates(
  payload: z.infer<typeof SubscriptionPreferencesUpdated>,
  subscriptionPreferences: SubscriptionPreferenceInstance,
) {
  if (
    !('email_notifications_enabled' in payload) &&
    !('recap_email_enabled' in payload) &&
    !('digest_email_enabled' in payload)
  )
    return;

  // Remove email schedules -> all emails disabled
  if (payload.email_notifications_enabled === false) {
    const provider = notificationsProvider();
    const existingSchedules = await provider.getSchedules({
      user_id: String(payload.user_id),
    });
    const ids = existingSchedules
      .filter(
        (s) =>
          s.workflow === WorkflowKeys.EmailDigest ||
          s.workflow === WorkflowKeys.EmailRecap,
      )
      .map((s) => s.id);

    if (ids.length) {
      const deletedSchedules = await provider.deleteSchedules({
        schedule_ids: ids,
      });
      const allDeleted = ids.every((id) => deletedSchedules.has(id));
      if (!allDeleted) {
        throw new Error('Failed to delete schedules');
      }
    }
    return;
  }

  // Add email schedules if a new email type is enabled
  if (subscriptionPreferences.email_notifications_enabled === true) {
    if (payload.recap_email_enabled === true) {
      await createScheduleIfNotExists(
        WorkflowKeys.EmailRecap,
        String(payload.user_id),
      );
    }

    if (payload.digest_email_enabled === true) {
      await createScheduleIfNotExists(
        WorkflowKeys.EmailDigest,
        String(payload.user_id),
      );
    }
  }

  // Remove specific email schedules
  if (payload.recap_email_enabled === false) {
    await deleteScheduleIfExists(
      WorkflowKeys.EmailRecap,
      String(payload.user_id),
    );
  }

  if (payload.digest_email_enabled === false) {
    await deleteScheduleIfExists(
      WorkflowKeys.EmailDigest,
      String(payload.user_id),
    );
  }
}

export const processSubscriptionPreferencesUpdated: EventHandler<
  'SubscriptionPreferencesUpdated',
  typeof output
> = async ({ payload }) => {
  const provider = notificationsProvider();
  const subPreferences = await models.SubscriptionPreference.findOne({
    where: {
      user_id: payload.user_id,
    },
  });

  if (!subPreferences) {
    throw new Error('Failed to find user subscription preferences');
  }

  if (config.NOTIFICATIONS.SEND_EMAILS || config.NODE_ENV === 'test') {
    await handleEmailPreferenceUpdates(payload, subPreferences);
  }

  if (config.PUSH_NOTIFICATIONS.FLAG_KNOCK_PUSH_NOTIFICATIONS_ENABLED) {
    const userProperties: { [key: string]: boolean } = {};
    const keys = [
      'mobile_push_notifications_enabled',
      'mobile_push_discussion_activity_enabled',
      'mobile_push_admin_alerts_enabled',
    ];
    keys.forEach((key) => {
      if (key in payload) {
        userProperties[key] = payload[key];
      }
    });

    if (Object.keys(userProperties).length) {
      await provider.identifyUser({
        user_id: String(payload.user_id),
        user_properties: userProperties,
      });
    }
  }

  return true;
};

1	import {
2	EventHandler,
3	logger,
4	notificationsProvider,
5	RepeatFrequency,
6	SubscriptionPreferencesUpdated,
7	WorkflowKeys,
8	} from '@hicommonwealth/core';
9	import { models, SubscriptionPreferenceInstance } from '@hicommonwealth/model';
10	import { DaysOfWeek } from '@knocklabs/node';
11	import z from 'zod';
12	import { config } from '../../../config';
13
14	const log = logger(import.meta);	1✔
15
16	const output = z.boolean();	1✔
17
18	function mapDateToDaysOfWeek(
19	date: Date,
20	): (typeof DaysOfWeek)[keyof typeof DaysOfWeek] {
21	switch (date.getDay()) {	1!
22	case 0:
23	return DaysOfWeek.Sun;	×
24	case 1:
25	return DaysOfWeek.Mon;	×
26	case 2:
UNCOV 27	return DaysOfWeek.Tue;	×
28	case 3:
29	return DaysOfWeek.Wed;	1✔
30	case 4:
31	return DaysOfWeek.Thu;	×
32	case 5:
33	return DaysOfWeek.Fri;	×
34	default:
35	return DaysOfWeek.Sat;	×
36	}
37	}
38
39	async function createScheduleIfNotExists(
40	workflowKey: WorkflowKeys.EmailRecap \| WorkflowKeys.EmailDigest,
41	userId: string,
42	): Promise<boolean> {
43	const provider = notificationsProvider();	2✔
44
45	const existingSchedules = await provider.getSchedules({	2✔
46	user_id: userId,
47	workflow_id: workflowKey,
48	});
49
50	if (existingSchedules.length === 0) {	2✔
51	await provider.createSchedules({	1✔
52	user_ids: [userId],
53	workflow_id: workflowKey,
54	schedule: [
55	{
56	frequency: RepeatFrequency.Weekly,
57	days: [mapDateToDaysOfWeek(new Date())],
58	hours: 12,
59	},
60	],
61	});
62	return true;	1✔
63	} else if (existingSchedules.length > 1) {	1!
64	log.error(	×
65	`User ${userId} has more than 1 scheduled ${workflowKey} workflow run`,
66	undefined,
67	{
68	userId,
69	workflowKey,
70	existingSchedules,
71	},
72	);
73	return false;	×
74	}
75
76	return true;	1✔
77	}
78
79	async function deleteScheduleIfExists(
80	workflowKey: WorkflowKeys.EmailRecap \| WorkflowKeys.EmailDigest,
81	userId: string,
82	): Promise<boolean> {
83	const provider = notificationsProvider();	2✔
84
85	const existingSchedules = await provider.getSchedules({	2✔
86	user_id: userId,
87	workflow_id: workflowKey,
88	});
89
90	if (existingSchedules.length === 0) return true;	2✔
91
92	await provider.deleteSchedules({	1✔
93	schedule_ids: existingSchedules.map((s) => s.id),	1✔
94	});
95
96	return true;	1✔
97	}
98
99	async function handleEmailPreferenceUpdates(
100	payload: z.infer<typeof SubscriptionPreferencesUpdated>,
101	subscriptionPreferences: SubscriptionPreferenceInstance,
102	) {
103	if (	5!
104	!('email_notifications_enabled' in payload) &&	18!
105	!('recap_email_enabled' in payload) &&
106	!('digest_email_enabled' in payload)
107	)
108	return;	×
109
110	// Remove email schedules -> all emails disabled
111	if (payload.email_notifications_enabled === false) {	5✔
112	const provider = notificationsProvider();	1✔
113	const existingSchedules = await provider.getSchedules({	1✔
114	user_id: String(payload.user_id),
115	});
116	const ids = existingSchedules	1✔
117	.filter(
118	(s) =>
119	s.workflow === WorkflowKeys.EmailDigest \|\|	2✔
120	s.workflow === WorkflowKeys.EmailRecap,
121	)
122	.map((s) => s.id);	2✔
123
124	if (ids.length) {	1!
125	const deletedSchedules = await provider.deleteSchedules({	1✔
126	schedule_ids: ids,
127	});
128	const allDeleted = ids.every((id) => deletedSchedules.has(id));	2✔
129	if (!allDeleted) {	1!
130	throw new Error('Failed to delete schedules');	×
131	}
132	}
133	return;	1✔
134	}
135
136	// Add email schedules if a new email type is enabled
137	if (subscriptionPreferences.email_notifications_enabled === true) {	4!
138	if (payload.recap_email_enabled === true) {	4✔
139	await createScheduleIfNotExists(	2✔
140	WorkflowKeys.EmailRecap,
141	String(payload.user_id),
142	);
143	}
144
145	if (payload.digest_email_enabled === true) {	4!
146	await createScheduleIfNotExists(	×
147	WorkflowKeys.EmailDigest,
148	String(payload.user_id),
149	);
150	}
151	}
152
153	// Remove specific email schedules
154	if (payload.recap_email_enabled === false) {	4✔
155	await deleteScheduleIfExists(	2✔
156	WorkflowKeys.EmailRecap,
157	String(payload.user_id),
158	);
159	}
160
161	if (payload.digest_email_enabled === false) {	4!
162	await deleteScheduleIfExists(	×
163	WorkflowKeys.EmailDigest,
164	String(payload.user_id),
165	);
166	}
167	}
168
169	export const processSubscriptionPreferencesUpdated: EventHandler<
170	'SubscriptionPreferencesUpdated',
171	typeof output
172	> = async ({ payload }) => {	1✔
173	const provider = notificationsProvider();	5✔
174	const subPreferences = await models.SubscriptionPreference.findOne({	5✔
175	where: {
176	user_id: payload.user_id,
177	},
178	});
179
180	if (!subPreferences) {	5!
181	throw new Error('Failed to find user subscription preferences');	×
182	}
183
184	if (config.NOTIFICATIONS.SEND_EMAILS \|\| config.NODE_ENV === 'test') {	5!
185	await handleEmailPreferenceUpdates(payload, subPreferences);	5✔
186	}
187
188	if (config.PUSH_NOTIFICATIONS.FLAG_KNOCK_PUSH_NOTIFICATIONS_ENABLED) {	5!
189	const userProperties: { [key: string]: boolean } = {};	×
190	const keys = [	×
191	'mobile_push_notifications_enabled',
192	'mobile_push_discussion_activity_enabled',
193	'mobile_push_admin_alerts_enabled',
194	];
195	keys.forEach((key) => {	×
196	if (key in payload) {	×
197	userProperties[key] = payload[key];	×
198	}
199	});
200
201	if (Object.keys(userProperties).length) {	×
202	await provider.identifyUser({	×
203	user_id: String(payload.user_id),
204	user_properties: userProperties,
205	});
206	}
207	}
208
209	return true;	5✔
210	};

hicommonwealth / commonwealth / 10907823301

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