11597407145

Committed 30 Oct 2024 04:20PM UTC coverage: 89.423% (+0.3%) from 89.135%

Build # 11597407145

Build Type

Pull #2063

github

Committed by

PooyaRaki

Commit Message

Remove legacy notification datasource, Add tests for notification repository

Pull Request Pull Request #2063: Notification migration

Run Details

2609 of 3293 branches covered (79.23%)

Branch coverage included in aggregate %.

151 of 204 new or added lines in 16 files covered. (74.02%)

1 existing line in 1 file now uncovered.

8999 of 9688 relevant lines covered (92.89%)

401.04 hits per line

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

31.58

/src/domain/notifications/v2/notifications.repository.ts

import { UpsertSubscriptionsDto } from '@/routes/notifications/v1/entities/upsert-subscriptions.dto.entity';
import { FirebaseNotification } from '@/datasources/push-notifications-api/entities/firebase-notification.entity';
import { IPushNotificationsApi } from '@/domain/interfaces/push-notifications-api.interface';
import { UUID } from 'crypto';
import type { INotificationsRepositoryV2 } from '@/domain/notifications/v2/notifications.repository.interface';
import {
  Inject,
  Injectable,
  UnauthorizedException,
  UnprocessableEntityException,
} from '@nestjs/common';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { get } from 'lodash';
import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';
import { NotificationSubscription } from '@/datasources/notifications/entities/notification-subscription.entity.db';
import { NotificationDevice } from '@/datasources/notifications/entities/notification-devices.entity.db';
import { NotificationType } from '@/datasources/notifications/entities/notification-type.entity.db';
import { In } from 'typeorm';
import { PostgresDatabaseService } from '@/datasources/db/v2/postgres-database.service';
import { NotificationSubscriptionNotificationType } from '@/datasources/notifications/entities/notification-subscription-notification-type.entity.db';

@Injectable()
export class NotificationsRepositoryV2 implements INotificationsRepositoryV2 {
  /**
   * Firebase REST error message for the HTTP v1 API relevant to token registration:
   *
   * This error can be caused by missing registration tokens, or unregistered tokens.
   *
   * Missing Registration: If the message's target is a token value, check that the
   * request contains a registration token.
   *
   * Not registered: An existing registration token may cease to be valid in a number
   * of scenarios, including:
   * - If the client app unregisters with FCM.
   * - If the client app is automatically unregistered, which can happen if the user
   *   uninstalls the application. For example, on iOS, if the APNs Feedback Service
   *   reported the APNs token as invalid.
   * - If the registration token expires (for example, Google might decide to refresh
   *   registration tokens, or the APNs token has expired for iOS devices).
   * - If the client app is updated but the new version is not configured to receive
   *   messages.
   *
   * For all these cases, remove this registration token from the app server and stop
   * using it to send messages.
   *
   * @see https://firebase.google.com/docs/cloud-messaging/send-message#rest
   */
  static readonly UnregisteredErrorCode = 404;
  static readonly UnregisteredErrorStatus = 'UNREGISTERED';

  constructor(
    @Inject(IPushNotificationsApi)
    private readonly pushNotificationsApi: IPushNotificationsApi,
    @Inject(LoggingService)
    private readonly loggingService: ILoggingService,

    @Inject(PostgresDatabaseService)
    private readonly postgresDatabaseService: PostgresDatabaseService,
  ) {}

  public async enqueueNotification(args: {
    token: string;
    deviceUuid: UUID;
    notification: FirebaseNotification;
  }): Promise<void> {
    try {
      await this.pushNotificationsApi.enqueueNotification(
        args.token,
        args.notification,
      );
    } catch (e) {
      if (this.isTokenUnregistered(e)) {
        this.loggingService.info(
          `Deleting device due to stale token ${args.deviceUuid}: ${e}`,
        );
        await this.deleteDevice(args.deviceUuid)
          // No need to log as datasource does
          .catch(() => null);
      } else {
        this.loggingService.info(`Failed to enqueue notification: ${e}`);
        throw new UnprocessableEntityException();
      }
    }
  }

  private isTokenUnregistered(error: unknown): boolean {
    const isNotFound =
      get(error, 'code') === NotificationsRepositoryV2.UnregisteredErrorCode;
    const isUnregistered =
      get(error, 'status') ===
      NotificationsRepositoryV2.UnregisteredErrorStatus;
    return isNotFound && isUnregistered;
  }

  public async upsertSubscriptions(args: {
    authPayload: AuthPayload;
    upsertSubscriptionsDto: UpsertSubscriptionsDto;
  }): Promise<{
    deviceUuid: UUID;
  }> {
    let device;
    await this.postgresDatabaseService.transaction(async () => {
      device = await this.upsertDevice(args);
      await this.deletePreviousSubscriptions({
        deviceId: device.id,
        signerAddress: args.authPayload.signer_address,
        upsertSubscriptionsDto: args.upsertSubscriptionsDto,
      });

      const subscriptions = await this.upsertSubscription({
        ...args,
        deviceId: device.id,
      });

      await this.insertSubscriptionNotificationTypes({
        subscriptions,
        upsertSubscriptionsDto: args.upsertSubscriptionsDto,
      });
    });

    return { deviceUuid: device!.device_uuid };
  }

  private async upsertDevice(args: {
    authPayload: AuthPayload;
    upsertSubscriptionsDto: UpsertSubscriptionsDto;
  }): Promise<Pick<NotificationDevice, 'id' | 'device_uuid'>> {
    const deviceUuid =
      args.upsertSubscriptionsDto.deviceUuid ?? crypto.randomUUID();

    const databaseTransaction =
      this.postgresDatabaseService.getTransactionRunner();

    const queryResult = await databaseTransaction.upsert(
      NotificationDevice,
      {
        device_uuid: deviceUuid,
        device_type: args.upsertSubscriptionsDto.deviceType,
        cloud_messaging_token: args.upsertSubscriptionsDto.cloudMessagingToken,
      },
      ['device_uuid'],
    );

    return { id: queryResult.identifiers[0].id, device_uuid: deviceUuid };
  }

  private async deletePreviousSubscriptions(args: {
    deviceId: number;
    signerAddress?: `0x${string}`;
    upsertSubscriptionsDto: UpsertSubscriptionsDto;
  }): Promise<void> {
    const databaseTransaction =
      this.postgresDatabaseService.getTransactionRunner();
    for (const safe of args.upsertSubscriptionsDto.safes) {
      await databaseTransaction
        .createQueryBuilder()
        .delete()
        .from(NotificationSubscription)
        .where(
          `chain_id = :chainId
          AND safe_address = :safeAddress
          AND push_notification_device.id = :deviceId
          AND (
            signer_address = :signerAddress OR signer_address IS NULL
          )`,
          {
            chainId: safe.chainId,
            safeAddress: safe.address,
            deviceId: args.deviceId,
            signerAddress: args.signerAddress ?? null,
          },
        )
        .execute();
    }
  }

  private async upsertSubscription(args: {
    authPayload: AuthPayload;
    upsertSubscriptionsDto: UpsertSubscriptionsDto;
    deviceId: number;
  }): Promise<Array<NotificationSubscription>> {
    const subscriptionsToInsert: Partial<NotificationSubscription>[] = [];
    const notificationTypes = [];
    for (const safe of args.upsertSubscriptionsDto.safes) {
      const device = new NotificationDevice();
      device.id = args.deviceId;
      subscriptionsToInsert.push({
        chain_id: safe.chainId,
        safe_address: safe.address,
        signer_address: args.authPayload.signer_address ?? null,
        push_notification_device: device,
      });

      notificationTypes.push(safe.notificationTypes);
    }

    const databaseTransaction =
      this.postgresDatabaseService.getTransactionRunner();

    const insertResult = await databaseTransaction.upsert(
      NotificationSubscription,
      subscriptionsToInsert,
      [
        'chain_id',
        'safe_address',
        'signer_address',
        'push_notification_device',
      ],
    );
    const subscriptionIds: Array<number> = insertResult.identifiers.map(
      (subscriptionIdentifier) => subscriptionIdentifier.id,
    );

    const subscriptions = await this.getSubscriptionsById(subscriptionIds);

    return subscriptions;
  }

  public async getSubscriptionsById(
    subscriptionIds: Array<number>,
  ): Promise<Array<NotificationSubscription>> {
    const databaseTransaction =
      this.postgresDatabaseService.getTransactionRunner();

    return await databaseTransaction.find(NotificationSubscription, {
      where: { id: In(subscriptionIds) },
    });
  }

  private async insertSubscriptionNotificationTypes(arg: {
    upsertSubscriptionsDto: UpsertSubscriptionsDto;
    subscriptions: Array<NotificationSubscription>;
  }): Promise<void> {
    const notificationTypesMap: Map<string, NotificationType> = new Map();
    const notificationTypes = arg.upsertSubscriptionsDto.safes.flatMap(
      (safe) => safe.notificationTypes,
    );
    const notificationTypesKeys: Map<string, undefined> = new Map();
    notificationTypes.forEach((notificationType) => {
      notificationTypesKeys.set(notificationType, undefined);
    });
    const notificationTypesKeysArray = [...notificationTypesKeys.keys()];

    const databaseTransaction =
      this.postgresDatabaseService.getTransactionRunner();

    const notificationTypeObjects = await databaseTransaction.find(
      NotificationType,
      {
        where: { name: In(notificationTypesKeysArray) },
      },
    );

    for (const notificationTypeObject of notificationTypeObjects) {
      notificationTypesMap.set(
        notificationTypeObject.name,
        notificationTypeObject,
      );
    }

    const subscriptionNotificationTypes = [];
    for (const safe of arg.upsertSubscriptionsDto.safes) {
      const safeSubscription = arg.subscriptions.find(
        (subscriptions) =>
          subscriptions.chain_id === safe.chainId &&
          subscriptions.safe_address === safe.address,
      );

      for (const notificationType of safe.notificationTypes) {
        subscriptionNotificationTypes.push({
          notification_subscription: safeSubscription,
          notification_type: notificationTypesMap.get(notificationType),
        });
      }
    }

    await databaseTransaction.upsert(
      NotificationSubscriptionNotificationType,
      subscriptionNotificationTypes,
      ['notification_subscription', 'notification_type'],
    );
  }

  public async getSafeSubscription(args: {
    authPayload: AuthPayload;
    deviceUuid: UUID;
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<Array<NotificationType>> {
    if (!args.authPayload.signer_address) {
      throw new UnauthorizedException();
    }

    const notificationTypeRepository =
      await this.postgresDatabaseService.getRepository(NotificationType);

    return await notificationTypeRepository.find({
      select: {
        name: true,
      },
      where: {
        notification_subscription_notification_type: {
          notification_subscription: {
            push_notification_device: {
              device_uuid: args.deviceUuid,
            },
            chain_id: args.chainId,
            safe_address: args.safeAddress,
            signer_address: args.authPayload.signer_address,
          },
        },
      },
    });
  }

  public async getSubscribersBySafe(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<
    Array<{
      subscriber: `0x${string}` | null;
      deviceUuid: UUID;
      cloudMessagingToken: string;
    }>
  > {
    const notificationSubscriptionRepository =
      await this.postgresDatabaseService.getRepository<NotificationSubscription>(
        NotificationSubscription,
      );

    const subscriptions = await notificationSubscriptionRepository.find({
      where: {
        chain_id: args.chainId,
        safe_address: args.safeAddress,
      },
      relations: ['push_notification_device'],
    });

    const output: Array<{
      subscriber: `0x${string}` | null;
      deviceUuid: UUID;
      cloudMessagingToken: string;
    }> = [];

    for (const subscription of subscriptions) {
      output.push({
        subscriber: subscription.signer_address,
        deviceUuid: subscription.push_notification_device.device_uuid,
        cloudMessagingToken:
          subscription.push_notification_device.cloud_messaging_token,
      });
    }

    return output;
  }

  public async deleteSubscription(args: {
    deviceUuid: UUID;
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<void> {
    const notificationsSubscriptionsRepository =
      await this.postgresDatabaseService.getRepository<NotificationSubscription>(
        NotificationSubscription,
      );
    const subscription = await notificationsSubscriptionsRepository.findOne({
      where: {
        chain_id: args.chainId,
        safe_address: args.safeAddress,
        push_notification_device: {
          device_uuid: args.deviceUuid,
        },
      },
    });

    if (subscription) {
      await notificationsSubscriptionsRepository.remove(subscription);
    }
  }

  public async deleteDevice(deviceUuid: UUID): Promise<void> {
    const notificationsDeviceRepository =
      await this.postgresDatabaseService.getRepository<NotificationDevice>(
        NotificationDevice,
      );

    await notificationsDeviceRepository.delete({
      device_uuid: deviceUuid,
    });
  }
}

1	import { UpsertSubscriptionsDto } from '@/routes/notifications/v1/entities/upsert-subscriptions.dto.entity';
2	import { FirebaseNotification } from '@/datasources/push-notifications-api/entities/firebase-notification.entity';
3	import { IPushNotificationsApi } from '@/domain/interfaces/push-notifications-api.interface';	108✔
4	import { UUID } from 'crypto';
5	import type { INotificationsRepositoryV2 } from '@/domain/notifications/v2/notifications.repository.interface';
6	import {	108✔
7	Inject,
8	Injectable,
9	UnauthorizedException,
10	UnprocessableEntityException,
11	} from '@nestjs/common';
12	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	108✔
13	import { get } from 'lodash';	108✔
14	import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';
15	import { NotificationSubscription } from '@/datasources/notifications/entities/notification-subscription.entity.db';	108✔
16	import { NotificationDevice } from '@/datasources/notifications/entities/notification-devices.entity.db';	108✔
17	import { NotificationType } from '@/datasources/notifications/entities/notification-type.entity.db';	108✔
18	import { In } from 'typeorm';	108✔
19	import { PostgresDatabaseService } from '@/datasources/db/v2/postgres-database.service';	108✔
20	import { NotificationSubscriptionNotificationType } from '@/datasources/notifications/entities/notification-subscription-notification-type.entity.db';	108✔
21
22	@Injectable()
23	export class NotificationsRepositoryV2 implements INotificationsRepositoryV2 {	108✔
24	/**
25	* Firebase REST error message for the HTTP v1 API relevant to token registration:
26	*
27	* This error can be caused by missing registration tokens, or unregistered tokens.
28	*
29	* Missing Registration: If the message's target is a token value, check that the
30	* request contains a registration token.
31	*
32	* Not registered: An existing registration token may cease to be valid in a number
33	* of scenarios, including:
34	* - If the client app unregisters with FCM.
35	* - If the client app is automatically unregistered, which can happen if the user
36	* uninstalls the application. For example, on iOS, if the APNs Feedback Service
37	* reported the APNs token as invalid.
38	* - If the registration token expires (for example, Google might decide to refresh
39	* registration tokens, or the APNs token has expired for iOS devices).
40	* - If the client app is updated but the new version is not configured to receive
41	* messages.
42	*
43	* For all these cases, remove this registration token from the app server and stop
44	* using it to send messages.
45	*
46	* @see https://firebase.google.com/docs/cloud-messaging/send-message#rest
47	*/
48	static readonly UnregisteredErrorCode = 404;	108✔
49	static readonly UnregisteredErrorStatus = 'UNREGISTERED';	108✔
50
51	constructor(
52	@Inject(IPushNotificationsApi)
53	private readonly pushNotificationsApi: IPushNotificationsApi,	984✔
54	@Inject(LoggingService)
55	private readonly loggingService: ILoggingService,	984✔
56
57	@Inject(PostgresDatabaseService)
58	private readonly postgresDatabaseService: PostgresDatabaseService,	984✔
59	) {}
60
61	public async enqueueNotification(args: {
62	token: string;
63	deviceUuid: UUID;
64	notification: FirebaseNotification;
65	}): Promise<void> {
66	try {	×
67	await this.pushNotificationsApi.enqueueNotification(	×
68	args.token,
69	args.notification,
70	);
71	} catch (e) {
72	if (this.isTokenUnregistered(e)) {	×
73	this.loggingService.info(	×
74	`Deleting device due to stale token ${args.deviceUuid}: ${e}`,
75	);
NEW 76	await this.deleteDevice(args.deviceUuid)	×
77	// No need to log as datasource does
78	.catch(() => null);	×
79	} else {
80	this.loggingService.info(`Failed to enqueue notification: ${e}`);	×
81	throw new UnprocessableEntityException();	×
82	}
83	}
84	}
85
86	private isTokenUnregistered(error: unknown): boolean {
87	const isNotFound =
88	get(error, 'code') === NotificationsRepositoryV2.UnregisteredErrorCode;	×
89	const isUnregistered =
90	get(error, 'status') ===	×
91	NotificationsRepositoryV2.UnregisteredErrorStatus;
92	return isNotFound && isUnregistered;	×
93	}
94
95	public async upsertSubscriptions(args: {
96	authPayload: AuthPayload;
97	upsertSubscriptionsDto: UpsertSubscriptionsDto;
98	}): Promise<{
99	deviceUuid: UUID;
100	}> {
101	let device;
NEW 102	await this.postgresDatabaseService.transaction(async () => {	×
NEW 103	device = await this.upsertDevice(args);	×
NEW 104	await this.deletePreviousSubscriptions({	×
105	deviceId: device.id,
106	signerAddress: args.authPayload.signer_address,
107	upsertSubscriptionsDto: args.upsertSubscriptionsDto,
108	});
109
NEW 110	const subscriptions = await this.upsertSubscription({	×
111	...args,
112	deviceId: device.id,
113	});
114
NEW 115	await this.insertSubscriptionNotificationTypes({	×
116	subscriptions,
117	upsertSubscriptionsDto: args.upsertSubscriptionsDto,
118	});
119	});
120
NEW 121	return { deviceUuid: device!.device_uuid };	×
122	}
123
124	private async upsertDevice(args: {
125	authPayload: AuthPayload;
126	upsertSubscriptionsDto: UpsertSubscriptionsDto;
127	}): Promise<Pick<NotificationDevice, 'id' \| 'device_uuid'>> {
128	const deviceUuid =
NEW 129	args.upsertSubscriptionsDto.deviceUuid ?? crypto.randomUUID();	×
130
131	const databaseTransaction =
NEW 132	this.postgresDatabaseService.getTransactionRunner();	×
133
NEW 134	const queryResult = await databaseTransaction.upsert(	×
135	NotificationDevice,
136	{
137	device_uuid: deviceUuid,
138	device_type: args.upsertSubscriptionsDto.deviceType,
139	cloud_messaging_token: args.upsertSubscriptionsDto.cloudMessagingToken,
140	},
141	['device_uuid'],
142	);
143
NEW 144	return { id: queryResult.identifiers[0].id, device_uuid: deviceUuid };	×
145	}
146
147	private async deletePreviousSubscriptions(args: {
148	deviceId: number;
149	signerAddress?: `0x${string}`;
150	upsertSubscriptionsDto: UpsertSubscriptionsDto;
151	}): Promise<void> {
152	const databaseTransaction =
NEW 153	this.postgresDatabaseService.getTransactionRunner();	×
NEW 154	for (const safe of args.upsertSubscriptionsDto.safes) {	×
NEW 155	await databaseTransaction	×
156	.createQueryBuilder()
157	.delete()
158	.from(NotificationSubscription)
159	.where(
160	`chain_id = :chainId
161	AND safe_address = :safeAddress
162	AND push_notification_device.id = :deviceId
163	AND (
164	signer_address = :signerAddress OR signer_address IS NULL
165	)`,
166	{
167	chainId: safe.chainId,
168	safeAddress: safe.address,
169	deviceId: args.deviceId,
170	signerAddress: args.signerAddress ?? null,	×
171	},
172	)
173	.execute();
174	}
175	}
176
177	private async upsertSubscription(args: {
178	authPayload: AuthPayload;
179	upsertSubscriptionsDto: UpsertSubscriptionsDto;
180	deviceId: number;
181	}): Promise<Array<NotificationSubscription>> {
NEW 182	const subscriptionsToInsert: Partial<NotificationSubscription>[] = [];	×
NEW 183	const notificationTypes = [];	×
NEW 184	for (const safe of args.upsertSubscriptionsDto.safes) {	×
NEW 185	const device = new NotificationDevice();	×
NEW 186	device.id = args.deviceId;	×
NEW 187	subscriptionsToInsert.push({	×
188	chain_id: safe.chainId,
189	safe_address: safe.address,
190	signer_address: args.authPayload.signer_address ?? null,	×
191	push_notification_device: device,
192	});
193
NEW 194	notificationTypes.push(safe.notificationTypes);	×
195	}
196
197	const databaseTransaction =
NEW 198	this.postgresDatabaseService.getTransactionRunner();	×
199
NEW 200	const insertResult = await databaseTransaction.upsert(	×
201	NotificationSubscription,
202	subscriptionsToInsert,
203	[
204	'chain_id',
205	'safe_address',
206	'signer_address',
207	'push_notification_device',
208	],
209	);
NEW 210	const subscriptionIds: Array<number> = insertResult.identifiers.map(	×
NEW 211	(subscriptionIdentifier) => subscriptionIdentifier.id,	×
212	);
213
NEW 214	const subscriptions = await this.getSubscriptionsById(subscriptionIds);	×
215
NEW 216	return subscriptions;	×
217	}
218
219	public async getSubscriptionsById(
220	subscriptionIds: Array<number>,
221	): Promise<Array<NotificationSubscription>> {
222	const databaseTransaction =
NEW 223	this.postgresDatabaseService.getTransactionRunner();	×
224
NEW 225	return await databaseTransaction.find(NotificationSubscription, {	×
226	where: { id: In(subscriptionIds) },
227	});
228	}
229
230	private async insertSubscriptionNotificationTypes(arg: {
231	upsertSubscriptionsDto: UpsertSubscriptionsDto;
232	subscriptions: Array<NotificationSubscription>;
233	}): Promise<void> {
NEW 234	const notificationTypesMap: Map<string, NotificationType> = new Map();	×
NEW 235	const notificationTypes = arg.upsertSubscriptionsDto.safes.flatMap(	×
NEW 236	(safe) => safe.notificationTypes,	×
237	);
NEW 238	const notificationTypesKeys: Map<string, undefined> = new Map();	×
NEW 239	notificationTypes.forEach((notificationType) => {	×
NEW 240	notificationTypesKeys.set(notificationType, undefined);	×
241	});
NEW 242	const notificationTypesKeysArray = [...notificationTypesKeys.keys()];	×
243
244	const databaseTransaction =
NEW 245	this.postgresDatabaseService.getTransactionRunner();	×
246
NEW 247	const notificationTypeObjects = await databaseTransaction.find(	×
248	NotificationType,
249	{
250	where: { name: In(notificationTypesKeysArray) },
251	},
252	);
253
NEW 254	for (const notificationTypeObject of notificationTypeObjects) {	×
NEW 255	notificationTypesMap.set(	×
256	notificationTypeObject.name,
257	notificationTypeObject,
258	);
259	}
260
NEW 261	const subscriptionNotificationTypes = [];	×
NEW 262	for (const safe of arg.upsertSubscriptionsDto.safes) {	×
NEW 263	const safeSubscription = arg.subscriptions.find(	×
264	(subscriptions) =>
NEW 265	subscriptions.chain_id === safe.chainId &&	×
266	subscriptions.safe_address === safe.address,
267	);
268
NEW 269	for (const notificationType of safe.notificationTypes) {	×
NEW 270	subscriptionNotificationTypes.push({	×
271	notification_subscription: safeSubscription,
272	notification_type: notificationTypesMap.get(notificationType),
273	});
274	}
275	}
276
NEW 277	await databaseTransaction.upsert(	×
278	NotificationSubscriptionNotificationType,
279	subscriptionNotificationTypes,
280	['notification_subscription', 'notification_type'],
281	);
282	}
283
284	public async getSafeSubscription(args: {
285	authPayload: AuthPayload;
286	deviceUuid: UUID;
287	chainId: string;
288	safeAddress: `0x${string}`;
289	}): Promise<Array<NotificationType>> {
290	if (!args.authPayload.signer_address) {	6✔
291	throw new UnauthorizedException();	2✔
292	}
293
294	const notificationTypeRepository =
295	await this.postgresDatabaseService.getRepository(NotificationType);	4✔
296
297	return await notificationTypeRepository.find({	4✔
298	select: {
299	name: true,
300	},
301	where: {
302	notification_subscription_notification_type: {
303	notification_subscription: {
304	push_notification_device: {
305	device_uuid: args.deviceUuid,
306	},
307	chain_id: args.chainId,
308	safe_address: args.safeAddress,
309	signer_address: args.authPayload.signer_address,
310	},
311	},
312	},
313	});
314	}
315
316	public async getSubscribersBySafe(args: {
317	chainId: string;
318	safeAddress: `0x${string}`;
319	}): Promise<
320	Array<{
321	subscriber: `0x${string}` \| null;
322	deviceUuid: UUID;
323	cloudMessagingToken: string;
324	}>
325	> {
326	const notificationSubscriptionRepository =
327	await this.postgresDatabaseService.getRepository<NotificationSubscription>(	4✔
328	NotificationSubscription,
329	);
330
331	const subscriptions = await notificationSubscriptionRepository.find({	4✔
332	where: {
333	chain_id: args.chainId,
334	safe_address: args.safeAddress,
335	},
336	relations: ['push_notification_device'],
337	});
338
339	const output: Array<{
340	subscriber: `0x${string}` \| null;
341	deviceUuid: UUID;
342	cloudMessagingToken: string;
343	}> = [];	4✔
344
345	for (const subscription of subscriptions) {	4✔
346	output.push({	10✔
347	subscriber: subscription.signer_address,
348	deviceUuid: subscription.push_notification_device.device_uuid,
349	cloudMessagingToken:
350	subscription.push_notification_device.cloud_messaging_token,
351	});
352	}
353
354	return output;	4✔
355	}
356
357	public async deleteSubscription(args: {
358	deviceUuid: UUID;
359	chainId: string;
360	safeAddress: `0x${string}`;
361	}): Promise<void> {
362	const notificationsSubscriptionsRepository =
363	await this.postgresDatabaseService.getRepository<NotificationSubscription>(	4✔
364	NotificationSubscription,
365	);
366	const subscription = await notificationsSubscriptionsRepository.findOne({	4✔
367	where: {
368	chain_id: args.chainId,
369	safe_address: args.safeAddress,
370	push_notification_device: {
371	device_uuid: args.deviceUuid,
372	},
373	},
374	});
375
376	if (subscription) {	4✔
377	await notificationsSubscriptionsRepository.remove(subscription);	2✔
378	}
379	}
380
381	public async deleteDevice(deviceUuid: UUID): Promise<void> {
382	const notificationsDeviceRepository =
383	await this.postgresDatabaseService.getRepository<NotificationDevice>(	2✔
384	NotificationDevice,
385	);
386
387	await notificationsDeviceRepository.delete({	2✔
388	device_uuid: deviceUuid,
389	});
390	}
391	}

safe-global / safe-client-gateway / 11597407145

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