@spytecgps/nova-orm 1.2.29-rc3 → 1.2.29-rc5

package/dist/repositories/userActivations/index.js

@@ -6,7 +6,6 @@ import { createUserActivationEvent } from './createUserActivationEvent';
 import { createUserActivationMetric } from './createUserActivationMetric';
 import { deleteUserActivation } from './deleteUserActivation';
 import { getLastActivationDevice } from './getLastActivationDevice';
-import { getUserActivationById } from './getUserActivationById';
 import { getUserActivationDevices } from './getUserActivationDevices';
 import { getUserActivationDevicesByClientId } from './getUserActivationDevicesByClientId';
 import { getUserActivationMetrics } from './getUserActivationMetrics';
@@ -25,7 +24,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async createUserActivation(params) {
         this.logger.trace(params, 'UserActivationsRepository::createUserActivation started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await createUserActivation(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserActivationsRepository::createUserActivation result');
         return result;
@@ -41,7 +40,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async getUserActivations(params) {
         this.logger.trace(params, 'UserActivationsRepository::getUserActivations started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getUserActivations(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserActivationsRepository::getUserActivations result');
         return result;
@@ -54,7 +53,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async deleteUserActivation(params) {
         this.logger.trace(params, 'UserActivationsRepository::deleteUserActivation started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await deleteUserActivation(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'UserActivationsRepository::deleteUserActivation result');
         return result;
@@ -70,7 +69,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async getUserActivationDevices(params) {
         this.logger.trace(params, 'UserActivationsRepository::getUserActivationDevices started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getUserActivationDevices(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserActivationsRepository::getUserActivationDevices result');
         return result;
@@ -84,7 +83,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async getUserActivationDevicesByClientId(params) {
         this.logger.trace(params, 'UserActivationsRepository::getUserActivationDevicesByClientId started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getUserActivationDevicesByClientId(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserActivationsRepository::getUserActivationDevicesByClientId result');
         return result;
@@ -114,7 +113,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async createUserActivationDevice(params) {
         this.logger.trace(params, 'UserActivationsRepository::createUserActivationDevice started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await createUserActivationDevice(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserActivationsRepository::createUserActivationDevice result');
         return result;
@@ -133,7 +132,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async getLastActivationDevice(params) {
         this.logger.trace(params, 'UserActivationsRepository::getLastActivationDevice started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getLastActivationDevice(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserActivationsRepository::getLastActivationDevice result');
         return result;
@@ -155,7 +154,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async updateUserActivationDevice(params) {
         this.logger.trace(params, 'UserActivationsRepository::updateUserActivationDevice started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await updateUserActivationDevice(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'UserActivationsRepository::updateUserActivationDevice result');
         return result;
@@ -169,7 +168,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async getUserActivationMetrics(params) {
         this.logger.trace(params, 'UserActivationsRepository::getUserActivationMetrics started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getUserActivationMetrics(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserActivationsRepository::getUserActivationMetrics result');
         return result;
@@ -184,7 +183,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async updateUserActivationMetrics(params) {
         this.logger.trace(params, 'UserActivationsRepository::updateUserActivationMetrics started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await updateUserActivationMetrics(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'UserActivationsRepository::updateUserActivationMetrics result');
         return result;
@@ -204,7 +203,7 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async createUserActivationEvent(params) {
         this.logger.trace(params, 'UserActivationsRepository::createUserActivationEvent started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await createUserActivationEvent(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserActivationsRepository::createUserActivationEvent result');
         return result;
@@ -222,17 +221,9 @@ export class UserActivationsRepository extends BaseRepository {
      */
     async createUserActivationMetric(params) {
         this.logger.trace(params, 'UserActivationsRepository::createUserActivationMetric started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await createUserActivationMetric(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserActivationsRepository::createUserActivationMetric result');
         return result;
     }
-    async getUserActivationById(params) {
-        this.logger.trace(params, 'UserActivationsRepository::getUserActivationById started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
-        const result = await getUserActivationById(novaDataSource, params, this.logger);
-        this.logger.trace(result, 'UserActivationsRepository::getUserActivationById result');
-        return result;
-    }
 }
-//# sourceMappingURL=index.js.map

package/dist/repositories/userActivations/updateUserActivationDevice.js

@@ -37,4 +37,3 @@ export const updateUserActivationDevice = async (novaDataSource, params, logger)
         return result.affected > 0;
     }, 'UserActivationsRepository::updateUserActivationDevice');
 };
-//# sourceMappingURL=updateUserActivationDevice.js.map

package/dist/repositories/userActivations/updateUserActivationMetrics.js

@@ -59,4 +59,3 @@ export const updateUserActivationMetrics = async (novaDataSource, params, logger
         return result.affected > 0;
     }, 'UserActivationsRepository::UpdateUserActivationMetrics');
 };
-//# sourceMappingURL=updateUserActivationMetrics.js.map

package/dist/repositories/userAppFeedback/createUserAppFeedback.js

@@ -24,4 +24,3 @@ export const createUserAppFeedback = async (novaDataSource, params, logger) => {
         return await userAppFeedbackRepository.save(newUserAppFeedback);
     }, 'UserAppFeedbackRepository::createUserAppFeedback');
 };
-//# sourceMappingURL=createUserAppFeedback.js.map

package/dist/repositories/userAppFeedback/index.js

@@ -15,10 +15,9 @@ export class UserAppFeedbackRepository extends BaseRepository {
      */
     async createUserAppFeedback(params) {
         this.logger.trace(params, 'UserAppFeedbackRepository::createUserAppFeedback started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await createUserAppFeedback(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserAppFeedbackRepository::createUserAppFeedback result');
         return result;
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/repositories/userAppIncidents/getUserAppIncidents.js

@@ -10,9 +10,7 @@ export const getUserAppIncidents = async (novaDataSource, params, logger) => {
         logger.warn({ params }, 'UserAppIncidentsRepository::getUserAppIncidents - userId is not a valid UUID');
         return [];
     }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const userAppIncidentsRepository = dataSource.getRepository(UserAppIncident);
         const queryBuilder = userAppIncidentsRepository
             .createQueryBuilder('userAppIncident')
@@ -24,11 +22,7 @@ export const getUserAppIncidents = async (novaDataSource, params, logger) => {
             createdTo: params.filters.createdTo,
         })
             .orderBy('userAppIncident.createdAt', 'DESC');
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
         const result = await queryBuilder.getMany();
         return result;
-    }, 'UserAppIncidentsRepository::getUserAppIncidents', dbQueryRunner);
+    }, 'UserAppIncidentsRepository::getUserAppIncidents');
 };
-//# sourceMappingURL=getUserAppIncidents.js.map

package/dist/repositories/userAppIncidents/index.js

@@ -14,7 +14,7 @@ export class UserAppIncidentsRepository extends BaseRepository {
      */
     async getUserAppIncidents(params) {
         this.logger.trace(params, 'UserAppIncidentsRepository::getUserAppIncidents started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await getUserAppIncidents(novaDataSource, params, this.logger);
         this.logger.trace(result, 'UserAppIncidentsRepository::getUserAppIncidents result');
         return result;
@@ -55,10 +55,9 @@ export class UserAppIncidentsRepository extends BaseRepository {
      */
     async upsertUserAppIncident(params) {
         this.logger.trace(params, 'UserAppIncidentsRepository::upsertUserAppIncident started with params');
-        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger, this.replicaNovaDataSourceConfig);
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
         const result = await upsertUserAppIncident(novaDataSource, params, this.logger);
         this.logger.trace({ result }, 'UserAppIncidentsRepository::upsertUserAppIncident result');
         return result;
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/repositories/userAppIncidents/upsertUserAppIncident.js

@@ -51,4 +51,3 @@ export const upsertUserAppIncident = async (novaDataSource, params, logger) => {
         return result?.raw?.affectedRows > 0;
     }, 'UserAppIncidentsRepository::upsertUserAppIncident');
 };
-//# sourceMappingURL=upsertUserAppIncident.js.map

package/dist/repositories/userConfigurations/bulkCreateUserAlertConfigurations.js

@@ -3,7 +3,7 @@ import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
 export const bulkCreateUserAlertConfigurations = async (novaDataSource, params, logger) => {
     if (!params?.alertConfigurations?.length) {
         logger.warn({ params }, 'UserConfigurationsRepository::bulkCreateUserAlertConfigurations - missing required parameters');
-        return [];
+        return false;
     }
     return novaDataSource.safeQuery(async (dataSource) => {
         const userAlertConfigurationsRepository = dataSource.getRepository(UserAlertConfiguration);
@@ -12,12 +12,12 @@ export const bulkCreateUserAlertConfigurations = async (novaDataSource, params,
             if (!createUserAlertConfigurationParams?.userId ||
                 !createUserAlertConfigurationParams?.alertTypeId) {
                 logger.warn(createUserAlertConfigurationParams, 'UserConfigurationsRepository::bulkCreateUserAlertConfigurations - User alert configuration could not be created: missing required parameters');
-                return [];
+                return false;
             }
             const userIdBinaryBuffer = uuidStringToBinaryBuffer(createUserAlertConfigurationParams?.userId);
             if (!userIdBinaryBuffer?.length) {
                 logger.warn(createUserAlertConfigurationParams, 'UserConfigurationsRepository::bulkCreateUserAlertConfigurations - User alert configuration could not be created: user id should be a valid UUID');
-                return [];
+                return false;
             }
             const newUserAlertConfiguration = {
                 id: createUserAlertConfigurationParams?.id,
@@ -29,18 +29,18 @@ export const bulkCreateUserAlertConfigurations = async (novaDataSource, params,
                 pushNotification: createUserAlertConfigurationParams?.pushNotification,
                 alertValue: createUserAlertConfigurationParams?.alertValue,
                 alertMetadata: createUserAlertConfigurationParams?.alertMetadata,
-                name: createUserAlertConfigurationParams?.name,
-                createdBy: createUserAlertConfigurationParams?.createdBy,
-                enabled: createUserAlertConfigurationParams?.enabled,
-                filter: createUserAlertConfigurationParams?.filter,
             };
             userAlertConfigurationsToCreate.push(newUserAlertConfiguration);
         }
         if (!userAlertConfigurationsToCreate.length) {
-            return [];
+            return false;
         }
-        const result = await userAlertConfigurationsRepository.save(userAlertConfigurationsToCreate);
-        return result;
+        const result = await userAlertConfigurationsRepository
+            .createQueryBuilder()
+            .insert()
+            .into(UserAlertConfiguration)
+            .values(userAlertConfigurationsToCreate)
+            .execute();
+        return result.identifiers.length === userAlertConfigurationsToCreate.length;
     }, 'UserConfigurationsRepository::bulkCreateUserAlertConfigurations');
 };
-//# sourceMappingURL=bulkCreateUserAlertConfigurations.js.map

package/dist/repositories/userConfigurations/createDeviceAlertTimeWindows.d.ts

@@ -0,0 +1,5 @@
+import { DeviceAlertConfiguration } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { CreateDeviceAlertTimeWindowsParams } from '../../types/userConfigurations';
+export declare const createDeviceAlertTimeWindows: (novaDataSource: NovaDataSource, params: CreateDeviceAlertTimeWindowsParams, logger: Logger) => Promise<DeviceAlertConfiguration>;

package/dist/repositories/userConfigurations/createDeviceAlertTimeWindows.js

@@ -0,0 +1,36 @@
+import { DeviceAlertConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createDeviceAlertTimeWindows = async (novaDataSource, params, logger) => {
+    if (!params?.userId ||
+        !params?.clientId ||
+        !params?.alertTypeId ||
+        !params?.daysOfTheWeek ||
+        !params.startTime ||
+        !params.endTime ||
+        !params.imei) {
+        logger.warn({ params }, 'UserConfigurationsRepository::createDeviceAlertTimeWindows - missing required parameters');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'UserConfigurationsRepository::createDeviceAlertTimeWindows - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userConfigurationsRepository = dataSource.getRepository(DeviceAlertConfiguration);
+        const newAlertTimeWindowsConfig = {
+            id: params?.id ?? null,
+            alertTypeId: params?.alertTypeId,
+            clientId: params?.clientId,
+            userId: userIdBinaryBuffer,
+            daysOfTheWeek: params?.daysOfTheWeek,
+            startTime: params?.startTime,
+            endTime: params?.endTime,
+            alertConfigurationId: params?.alertConfigurationId ?? null,
+            filter: params?.filter ?? null,
+            imei: params?.imei,
+            label: params?.label ?? null,
+        };
+        return await userConfigurationsRepository.save(newAlertTimeWindowsConfig);
+    }, 'UserConfigurationsRepository::createDeviceAlertTimeWindows');
+};

package/dist/repositories/userConfigurations/createUserAlertTimeWindows.d.ts

@@ -0,0 +1,5 @@
+import { AlertTimeWindowConfiguration } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { CreateUserAlertTimeWindowsParams } from '../../types/userConfigurations';
+export declare const createUserAlertTimeWindows: (novaDataSource: NovaDataSource, params: CreateUserAlertTimeWindowsParams, logger: Logger) => Promise<AlertTimeWindowConfiguration>;

package/dist/repositories/userConfigurations/createUserAlertTimeWindows.js

@@ -0,0 +1,33 @@
+import { AlertTimeWindowConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserAlertTimeWindows = async (novaDataSource, params, logger) => {
+    if (!params?.userId ||
+        !params?.clientId ||
+        !params?.alertTypeId ||
+        !params?.daysOfTheWeek ||
+        !params.startTime ||
+        !params.endTime) {
+        logger.warn({ params }, 'UserConfigurationsRepository::createUserAlertTimeWindows - missing required parameters');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'UserConfigurationsRepository::createUserAlertTimeWindows - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userConfigurationsRepository = dataSource.getRepository(AlertTimeWindowConfiguration);
+        const newAlertTimeWindowsConfig = {
+            id: params?.id ?? null,
+            alertId: params?.alertTypeId,
+            clientId: params?.clientId,
+            userId: userIdBinaryBuffer,
+            daysOfTheWeek: params?.daysOfTheWeek,
+            startTime: params?.startTime,
+            endTime: params?.endTime,
+            alertConfigurationId: params?.alertConfigurationId ?? null,
+            label: params?.label ?? null,
+        };
+        return await userConfigurationsRepository.save(newAlertTimeWindowsConfig);
+    }, 'UserConfigurationsRepository::createUserAlertTimeWindows');
+};

package/dist/repositories/userConfigurations/createUserConfiguration.js

@@ -32,4 +32,3 @@ export const createUserConfiguration = async (novaDataSource, params, logger) =>
         return await userConfigurationsRepository.save(newUserConfiguration);
     }, 'UserConfigurationsRepository::createUserConfiguration');
 };
-//# sourceMappingURL=createUserConfiguration.js.map

package/dist/repositories/userConfigurations/deleteDeviceAlertTimeWindows.d.ts

@@ -0,0 +1,4 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { DeleteAlertTimeWindowsParams } from '../../types/userConfigurations';
+export declare const deleteDeviceAlertTimeWindows: (novaDataSource: NovaDataSource, params: DeleteAlertTimeWindowsParams, logger: Logger) => Promise<boolean>;

package/dist/repositories/userConfigurations/deleteDeviceAlertTimeWindows.js

@@ -0,0 +1,17 @@
+import { DeviceAlertConfiguration } from '../../entities';
+export const deleteDeviceAlertTimeWindows = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.configId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::deleteDeviceAlertTimeWindows - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userConfigurationsRepository = dataSource.getRepository(DeviceAlertConfiguration);
+        const queryBuilder = userConfigurationsRepository
+            .createQueryBuilder()
+            .delete()
+            .where('id = :id', { id: params?.filters?.configId });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserConfigurationsRepository::deleteDeviceAlertTimeWindows');
+};

package/dist/repositories/userConfigurations/deleteUserAlertConfigurations.js

@@ -8,23 +8,17 @@ export const deleteUserAlertConfigurations = async (novaDataSource, params, logg
     }
     const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
     // at least one filter is required
-    if (params?.filters?.userId && !userIdBinaryBuffer) {
+    if (!userIdBinaryBuffer) {
         logger.warn({ userId: params?.filters?.userId }, 'UserConfigurationsRepository::deleteUserAlertConfigurations - user id should be a valid UUID');
         return false;
     }
     return novaDataSource.safeQuery(async (dataSource) => {
         const userConfigurationsRepository = dataSource.getRepository(UserAlertConfiguration);
-        let queryBuilder = userConfigurationsRepository.createQueryBuilder().delete();
-        if (userIdBinaryBuffer) {
-            queryBuilder = queryBuilder.where('userId = :userId', { userId: userIdBinaryBuffer });
-        }
-        if (params?.filters?.userAlertConfigurationIds?.length) {
-            queryBuilder = queryBuilder.andWhere('id IN (:...userAlertConfigurationIds)', {
-                userAlertConfigurationIds: params.filters.userAlertConfigurationIds,
-            });
-        }
+        const queryBuilder = userConfigurationsRepository
+            .createQueryBuilder()
+            .delete()
+            .where('userId = :userId', { userId: userIdBinaryBuffer });
         const result = await queryBuilder.execute();
         return result.affected > 0;
     }, 'UserConfigurationsRepository::deleteUserAlertConfigurations');
 };
-//# sourceMappingURL=deleteUserAlertConfigurations.js.map

package/dist/repositories/userConfigurations/deleteUserAlertTimeWindows.d.ts

@@ -0,0 +1,4 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { DeleteAlertTimeWindowsParams } from '../../types/userConfigurations';
+export declare const deleteUserAlertTimeWindows: (novaDataSource: NovaDataSource, params: DeleteAlertTimeWindowsParams, logger: Logger) => Promise<boolean>;

package/dist/repositories/userConfigurations/deleteUserAlertTimeWindows.js

@@ -0,0 +1,17 @@
+import { AlertTimeWindowConfiguration } from '../../entities';
+export const deleteUserAlertTimeWindows = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.configId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::deleteUserAlertTimeWindows - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userConfigurationsRepository = dataSource.getRepository(AlertTimeWindowConfiguration);
+        const queryBuilder = userConfigurationsRepository
+            .createQueryBuilder()
+            .delete()
+            .where('id = :id', { id: params?.filters?.configId });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserConfigurationsRepository::deleteUserAlertTimeWindows');
+};

package/dist/repositories/userConfigurations/deleteUserConfiguration.js

@@ -21,4 +21,3 @@ export const deleteUserConfiguration = async (novaDataSource, params, logger) =>
         return result.affected > 0;
     }, 'UserConfigurationsRepository::deleteUserConfiguration');
 };
-//# sourceMappingURL=deleteUserConfiguration.js.map

package/dist/repositories/userConfigurations/getDeviceAlertTimeWindows.d.ts

@@ -0,0 +1,5 @@
+import { DeviceAlertConfiguration } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { GetDeviceAlertTimeWindowsParams } from '../../types/userConfigurations';
+export declare const getDeviceAlertTimeWindows: (novaDataSource: NovaDataSource, params: GetDeviceAlertTimeWindowsParams, logger: Logger) => Promise<DeviceAlertConfiguration[]>;

package/dist/repositories/userConfigurations/getDeviceAlertTimeWindows.js

@@ -0,0 +1,43 @@
+import { DeviceAlertConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getDeviceAlertTimeWindows = async (novaDataSource, params, logger) => {
+    // imei filter is required
+    if (!params?.filters?.imei &&
+        !params?.filters?.clientId &&
+        !params?.filters?.userId &&
+        !params?.filters?.configId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::getDeviceAlertTimeWindows - missing required parameters');
+        return [];
+    }
+    let userIdBinaryBuffer = null;
+    if (params?.filters?.userId) {
+        userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userAlertTimeWindowsRepository = dataSource.getRepository(DeviceAlertConfiguration);
+        let queryBuilder = userAlertTimeWindowsRepository.createQueryBuilder('deviceAlertConfiguration');
+        if (params?.filters?.configId) {
+            queryBuilder = queryBuilder.andWhere('deviceAlertConfiguration.id = :id', {
+                id: params.filters.configId,
+            });
+        }
+        if (params?.filters?.imei) {
+            queryBuilder = queryBuilder.andWhere('deviceAlertConfiguration.imei = :imei', {
+                imei: params.filters.imei,
+            });
+        }
+        if (params?.filters?.clientId) {
+            queryBuilder = queryBuilder.andWhere('deviceAlertConfiguration.clientId = :clientId', {
+                clientId: params.filters.clientId,
+            });
+        }
+        if (userIdBinaryBuffer) {
+            queryBuilder = queryBuilder.andWhere('deviceAlertConfiguration.userId = :userId', {
+                userId: userIdBinaryBuffer,
+            });
+        }
+        queryBuilder = queryBuilder.orderBy('deviceAlertConfiguration.alertTypeId');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UserConfigurationsRepository::getDeviceAlertTimeWindows');
+};

package/dist/repositories/userConfigurations/getUserAlertConfigurations.js

@@ -11,24 +11,15 @@ export const getUserAlertConfigurations = async (novaDataSource, params, logger)
         logger.warn({ params }, 'UserConfigurationsRepository::getUserAlertConfigurations - user id should be a valid UUID');
         return [];
     }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const userAlertConfigurationsRepository = dataSource.getRepository(UserAlertConfiguration);
         let queryBuilder = userAlertConfigurationsRepository.createQueryBuilder('userAlertConfiguration');
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
         queryBuilder = queryBuilder.innerJoinAndSelect('userAlertConfiguration.alertType', 'alertType', !params.filters.includeBeta ? `alertType.stage = 'prod'` : undefined);
         queryBuilder = queryBuilder.where('userAlertConfiguration.userId = :userId', {
             userId: userIdBinaryBuffer,
         });
-        if (params?.projectionOptions?.withNotificationRecipients) {
-            queryBuilder = queryBuilder.leftJoinAndSelect('userAlertConfiguration.notificationRecipients', 'notificationRecipient');
-        }
         queryBuilder = queryBuilder.orderBy('userAlertConfiguration.alertTypeId');
         const result = await queryBuilder.getMany();
         return result;
-    }, 'UserConfigurationsRepository::getUserAlertConfigurations', dbQueryRunner);
+    }, 'UserConfigurationsRepository::getUserAlertConfigurations');
 };
-//# sourceMappingURL=getUserAlertConfigurations.js.map

package/dist/repositories/userConfigurations/getUserAlertTimeWindows.d.ts

@@ -0,0 +1,5 @@
+import { AlertTimeWindowConfiguration } from '../../entities';
+import { NovaDataSource } from '../../novaDataSource';
+import { Logger } from '../../types/logger';
+import { GetUserAlertTimeWindowsParams } from '../../types/userConfigurations';
+export declare const getUserAlertTimeWindows: (novaDataSource: NovaDataSource, params: GetUserAlertTimeWindowsParams, logger: Logger) => Promise<AlertTimeWindowConfiguration[]>;

package/dist/repositories/userConfigurations/getUserAlertTimeWindows.js

@@ -0,0 +1,35 @@
+import { AlertTimeWindowConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserAlertTimeWindows = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.userId && !params?.filters?.clientId && !params?.filters?.configId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::getUserAlertTimeWindows - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userAlertTimeWindowsRepository = dataSource.getRepository(AlertTimeWindowConfiguration);
+        let queryBuilder = userAlertTimeWindowsRepository.createQueryBuilder('alertTimeWindowConfiguration');
+        if (params?.filters?.configId) {
+            queryBuilder = queryBuilder.where('alertTimeWindowConfiguration.id = :id', {
+                id: params.filters.configId,
+            });
+        }
+        if (params?.filters?.userId) {
+            const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+            if (!userIdBinaryBuffer) {
+                return [];
+            }
+            queryBuilder = queryBuilder.where('alertTimeWindowConfiguration.userId = :userId', {
+                userId: userIdBinaryBuffer,
+            });
+        }
+        if (params?.filters?.clientId) {
+            queryBuilder = queryBuilder.where('alertTimeWindowConfiguration.clientId = :clientId', {
+                clientId: params.filters.clientId,
+            });
+        }
+        queryBuilder = queryBuilder.orderBy('alertTimeWindowConfiguration.alertId');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UserConfigurationsRepository::getUserAlertTimeWindows');
+};

package/dist/repositories/userConfigurations/getUserConfigurations.js

@@ -11,14 +11,9 @@ export const getUserConfigurations = async (novaDataSource, params, logger) => {
         logger.warn({ params }, 'UserConfigurationsRepository::getUserConfigurations - user id should be a valid UUID');
         return [];
     }
-    // Force the query to run on master or slave
-    const dbQueryRunner = novaDataSource.createQueryRunnerFromParams(params);
-    return novaDataSource.safeQuery(async (dataSource, queryRunner) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
         const userConfigurationsRepository = dataSource.getRepository(UserConfiguration);
         let queryBuilder = userConfigurationsRepository.createQueryBuilder('userConfiguration');
-        if (queryRunner) {
-            queryBuilder.setQueryRunner(queryRunner);
-        }
         if (params.filters.clientId) {
             queryBuilder = queryBuilder.innerJoin('userConfiguration.user', 'user');
             queryBuilder = queryBuilder.andWhere('user.clientId = :clientId', {
@@ -32,6 +27,5 @@ export const getUserConfigurations = async (novaDataSource, params, logger) => {
         }
         const result = await queryBuilder.getMany();
         return result;
-    }, 'UserConfigurationsRepository::getUserConfigurations', dbQueryRunner);
+    }, 'UserConfigurationsRepository::getUserConfigurations');
 };
-//# sourceMappingURL=getUserConfigurations.js.map