@spytecgps/nova-orm 0.0.223 → 0.0.225

package/dist/repositories/userConfigurations/createUserConfiguration.js

@@ -0,0 +1,34 @@
+import { UserConfiguration } from '../../entities/userConfiguration';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserConfiguration = async (novaDataSource, params, logger) => {
+    if (!params?.userId || params?.isMetric == null) {
+        logger.warn({ params }, 'UserConfigurationsRepository::createUserConfiguration - missing required parameters');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'UserConfigurationsRepository::createUserConfiguration - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userConfigurationsRepository = dataSource.getRepository(UserConfiguration);
+        const now = new Date();
+        const newUserConfiguration = {
+            id: params?.id,
+            userId: userIdBinaryBuffer,
+            isMetric: params?.isMetric,
+            timezone: params?.timezone,
+            defaultMapLayer: params?.defaultMapLayer,
+            speedUnits: params?.speedUnits,
+            distanceUnits: params?.distanceUnits,
+            alertsNotificationsOn: params?.alertsNotificationsOn != null ? params?.alertsNotificationsOn : true,
+            dataSourceTypeId: params?.dataSourceTypeId,
+            homepage: params?.homepage,
+            temperatureUnits: params?.temperatureUnits,
+            addressFormat: params?.addressFormat,
+            createdAt: now,
+            modifiedAt: now,
+        };
+        return await userConfigurationsRepository.save(newUserConfiguration);
+    }, 'UserConfigurationsRepository::createUserConfiguration');
+};

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

@@ -0,0 +1,24 @@
+import { UserAlertConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const deleteUserAlertConfigurations = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::deleteUserAlertConfigurations - missing required parameters');
+        return false;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    // at least one filter is required
+    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);
+        const queryBuilder = userConfigurationsRepository
+            .createQueryBuilder()
+            .delete()
+            .where('userId = :userId', { userId: userIdBinaryBuffer });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserConfigurationsRepository::deleteUserAlertConfigurations');
+};

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

@@ -0,0 +1,23 @@
+import { UserConfiguration } from '../../entities/userConfiguration';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const deleteUserConfiguration = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::deleteUserConfiguration - missing required parameters');
+        return false;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (!userIdBinaryBuffer) {
+        logger.warn({ userId: params?.filters?.userId }, 'UserConfigurationsRepository::deleteUserConfiguration - user id should be a valid UUID');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userConfigurationsRepository = dataSource.getRepository(UserConfiguration);
+        const queryBuilder = userConfigurationsRepository
+            .createQueryBuilder()
+            .delete()
+            .where('userId = :userId', { userId: userIdBinaryBuffer });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserConfigurationsRepository::deleteUserConfiguration');
+};

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

@@ -0,0 +1,25 @@
+import { UserAlertConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserAlertConfigurations = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::getUserAlertConfigurations - missing required parameters');
+        return [];
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (!userIdBinaryBuffer) {
+        logger.warn({ params }, 'UserConfigurationsRepository::getUserAlertConfigurations - user id should be a valid UUID');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userAlertConfigurationsRepository = dataSource.getRepository(UserAlertConfiguration);
+        let queryBuilder = userAlertConfigurationsRepository.createQueryBuilder('userAlertConfiguration');
+        queryBuilder = queryBuilder.innerJoinAndSelect('userAlertConfiguration.alertType', 'alertType', !params.filters.includeBeta ? `alertType.stage = 'prod'` : undefined);
+        queryBuilder = queryBuilder.where('userAlertConfiguration.userId = :userId', {
+            userId: userIdBinaryBuffer,
+        });
+        queryBuilder = queryBuilder.orderBy('userAlertConfiguration.alertTypeId');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UserConfigurationsRepository::getUserAlertConfigurations');
+};

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

@@ -0,0 +1,31 @@
+import { UserConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserConfigurations = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.clientId && !params?.filters?.userId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::getUserConfigurations - missing required parameters');
+        return [];
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (params?.filters?.userId && !userIdBinaryBuffer) {
+        logger.warn({ params }, 'UserConfigurationsRepository::getUserConfigurations - user id should be a valid UUID');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userConfigurationsRepository = dataSource.getRepository(UserConfiguration);
+        let queryBuilder = userConfigurationsRepository.createQueryBuilder('userConfiguration');
+        if (params.filters.clientId) {
+            queryBuilder = queryBuilder.innerJoin('userConfiguration.user', 'user');
+            queryBuilder = queryBuilder.andWhere('user.clientId = :clientId', {
+                clientId: params.filters.clientId,
+            });
+        }
+        if (userIdBinaryBuffer) {
+            queryBuilder = queryBuilder.andWhere('userConfiguration.userId = :userId', {
+                userId: userIdBinaryBuffer,
+            });
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UserConfigurationsRepository::getUserConfigurations');
+};

package/dist/repositories/userConfigurations/index.js

@@ -0,0 +1,298 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { bulkCreateUserAlertConfigurations } from './bulkCreateUserAlertConfigurations';
+import { createDeviceAlertTimeWindows } from './createDeviceAlertTimeWindows';
+import { createUserAlertTimeWindows } from './createUserAlertTimeWindows';
+import { createUserConfiguration } from './createUserConfiguration';
+import { deleteDeviceAlertTimeWindows } from './deleteDeviceAlertTimeWindows';
+import { deleteUserAlertConfigurations } from './deleteUserAlertConfigurations';
+import { deleteUserAlertTimeWindows } from './deleteUserAlertTimeWindows';
+import { deleteUserConfiguration } from './deleteUserConfiguration';
+import { getDeviceAlertTimeWindows } from './getDeviceAlertTimeWindows';
+import { getUserAlertConfigurations } from './getUserAlertConfigurations';
+import { getUserAlertTimeWindows } from './getUserAlertTimeWindows';
+import { getUserConfigurations } from './getUserConfigurations';
+import { updateDeviceAlertTimeWindows } from './updateDeviceAlertTimeWindows';
+import { updateUserAlertConfigurations } from './updateUserAlertConfigurations';
+import { updateUserAlertTimeWindows } from './updateUserAlertTimeWindows';
+import { updateUserConfiguration } from './updateUserConfiguration';
+export class UserConfigurationsRepository extends BaseRepository {
+    /**
+     * Get user configurations
+     * @param {GetUserConfigurationsParams} params containing information to get user configurations
+     * - filters.clientId: The client id to obtain all user configurations from that client
+     * - filters.userId: The user id to obtain all user configurations from that user
+     * @returns The user configurations
+     */
+    async getUserConfigurations(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::getUserConfigurations started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserConfigurations(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserConfigurationsRepository::getUserConfigurations result');
+        return result;
+    }
+    /**
+     * Create user configuration
+     * @param {CreateUserConfigurationParams} params containing information to create a user configuration
+     * - id: The user configuration id, optional. If not provided, it will be generated
+     * - userId: The user id, required
+     * - isMetric: Whether is metric, required
+     * - timezone: The user timezone, optional
+     * - defaultMapLayer: The user default map layer, optional
+     * - speedUnits: The user speed units, optional
+     * - distanceUnits: The user distance units, optional
+     * - alertsNotificationsOn: The user alerts notifications on, optional. If not provided, it will be true
+     * - dataSourceTypeId: The user data source type id, optional
+     * - homepage: The user homepage, optional
+     * - temperatureUnits: The user temperature units, optional
+     * - addressFormat: The user address format, optional
+     * @returns The created user configuration
+     */
+    async createUserConfiguration(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::createUserConfiguration started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserConfiguration(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserConfigurationsRepository::createUserConfiguration result');
+        return result;
+    }
+    /**
+     * Create user alert time windows
+     * @param {CreateUserAlertTimeWindowsParams} params containing information to create a user alert time windows
+     * - id: The user alert time windows id, optional. If not provided, it will be generated
+     * - clientId: The client id, required
+     * - userId: The user id, required
+     * - alertConfigurationId: The alert configuration id, optional
+     * - daysOfTheWeek: The days of the week, required. It's a string of 7 characters, each one representing a day of the week, starting with Sunday. 1 means that the day is selected, 0 means that the day is not selected
+     * - startTime: The start time, required
+     * - endTime: The end time, required
+     * @returns {AlertTimeWindowConfiguration} The created user alert time windows
+     */
+    async createUserAlertTimeWindows(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::createUserAlertTimeWindows started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserAlertTimeWindows(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserConfigurationsRepository::createUserAlertTimeWindows result');
+        return result;
+    }
+    /**
+     * Create device alert time windows
+     * @param {CreateDeviceAlertTimeWindowsParams} params containing information to create a device alert time windows
+     * - id: The user alert time windows id, optional. If not provided, it will be generated
+     * - clientId: The client id, required
+     * - userId: The user id, required
+     * - alertConfigurationId: The alert configuration id, optional
+     * - daysOfTheWeek: The days of the week, required. It's a string of 7 characters, each one representing a day of the week, starting with Sunday. 1 means that the day is selected, 0 means that the day is not selected
+     * - startTime: The start time, required
+     * - endTime: The end time, required
+     * - imei: The imei, required
+     * - filter: The filter to apply on a specific alert type, optional
+     * @returns {DeviceAlertConfiguration}
+     */
+    async createDeviceAlertTimeWindows(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::createDeviceAlertTimeWindows started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createDeviceAlertTimeWindows(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserConfigurationsRepository::createDeviceAlertTimeWindows result');
+        return result;
+    }
+    /**
+     * Update user configuration
+     * @param {UpdateUserConfigurationParams} params containing information to update a user configuration
+     * Filters:
+     * - filters.userId: The user id to update the user configuration, required
+     * Values:
+     * One of the following values is required
+     * - values.timezone: The user timezone, optional
+     * - values.defaultMapLayer: The user default map layer, optional
+     * - values.speedUnits: The user speed units, optional
+     * - values.distanceUnits: The user distance units, optional
+     * - values.alertsNotificationsOn: The user alerts notifications on, optional
+     * - values.dataSourceTypeId: The user data source type id, optional
+     * - values.homepage: The user homepage, optional
+     * - values.temperatureUnits: The user temperature units, optional
+     * - values.addressFormat: The user address format, optional
+     * @returns Whether the user configuration was updated
+     */
+    async updateUserConfiguration(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::updateUserConfiguration started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateUserConfiguration(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserConfigurationsRepository::updateUserConfiguration result');
+        return result;
+    }
+    /**
+     * Delete user configuration
+     * @param {DeleteUserConfigurationParams} params containing information to delete a user configuration
+     * - filters.userId: The user id to delete the user configuration, required
+     * @returns Whether the user configuration was deleted
+     */
+    async deleteUserConfiguration(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::deleteUserConfiguration started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteUserConfiguration(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserConfigurationsRepository::deleteUserConfiguration result');
+        return result;
+    }
+    /**
+     * Get user alert configurations
+     * @param {GetUserAlertConfigurationsParams} params containing information to get user alert configurations
+     * - filters.userId: The user id to obtain all user alert configurations from that user, required
+     * - filters.includeBeta: Whether to include beta alert types, required
+     * @returns The user alert configurations
+     */
+    async getUserAlertConfigurations(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::getUserAlertConfigurations started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserAlertConfigurations(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserConfigurationsRepository::getUserAlertConfigurations result');
+        return result;
+    }
+    /**
+     * Get user alert time windows configurations
+     * @param {GetUserAlertTimeWindowsParams} params containing information to get user alert time windows configurations
+     * - filters.userId: The user id to obtain all user alert configurations from that user.
+     * - filters.clientId: The client id to obtain the configurations.
+     * @returns The user alert time windows configurations
+     */
+    async getUserAlertTimeWindows(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::getUserAlertConfigurations started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserAlertTimeWindows(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserConfigurationsRepository::getUserAlertTimeWindows result');
+        return result;
+    }
+    /**
+     * Get device alert time windows configurations
+     * @param {GetDeviceAlertTimeWindowsParams} params containing information to get device alert time windows configurations
+     * - filters.imei: The imei to obtain all user alert configurations from that device.
+     * - filters.clientId: The client id to obtain the configurations.
+     * @returns The user device time windows configurations
+     */
+    async getDeviceAlertTimeWindows(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::getUserAlertConfigurations started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getDeviceAlertTimeWindows(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserConfigurationsRepository::getDeviceAlertTimeWindows result');
+        return result;
+    }
+    /**
+     * Bulk create user alert configurations
+     * @param {BulkCreateUserAlertConfigurationsParams} params containing information to bulk create user alert configurations
+     * - alertConfigurations: The user alert configurations to create, required
+     * Each user alert configuration should contain:
+     * - id: The user alert configuration id, optional. If not provided, it will be generated
+     * - userId: The user id, required
+     * - alertTypeId: The alert type id, required
+     * - smsNotification: The user sms notification, optional
+     * - emailNotification: The user email notification, optional
+     * - appNotification: The user app notification, optional. If not provided, it will be true
+     * - pushNotification: The user push notification, optional. If not provided, it will be true
+     * - alertValue: The user alert value, optional
+     * - alertMetadata: The user alert metadata, optional
+     * @returns Whether the user alert configurations were created
+     */
+    async bulkCreateUserAlertConfigurations(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::bulkCreateUserAlertConfigurations started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await bulkCreateUserAlertConfigurations(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserConfigurationsRepository::bulkCreateUserAlertConfigurations result');
+        return result;
+    }
+    /**
+     * Update user alert configurations
+     * @param {UpdateUserAlertConfigurationsParams} params containing information to update user alert configurations
+     * Filters:
+     * - filters.userId: The user id to update the user alert configurations, required
+     * - filters.alertTypeId: The alert type id to update the user alert configurations, optional
+     * Values:
+     * One of the following values is required
+     * - values.smsNotification: The user sms notification, optional
+     * - values.emailNotification: The user email notification, optional
+     * - values.appNotification: The user app notification, optional
+     * - values.pushNotification: The user push notification, optional
+     * - values.alertValue: The user alert value, optional
+     * - values.alertMetadata: The user alert metadata, optional
+     * @returns Whether the user alert configurations were updated
+     */
+    async updateUserAlertConfigurations(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::updateUserAlertConfigurations started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateUserAlertConfigurations(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserConfigurationsRepository::updateUserAlertConfigurations result');
+        return result;
+    }
+    /**
+     * Delete user alert configurations
+     * @param {DeleteUserAlertConfigurationsParams} params containing information to delete user alert configurations
+     * - filters.userId: The user id to delete the user alert configurations, required
+     * @returns Whether the user alert configurations were deleted
+     */
+    async deleteUserAlertConfigurations(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::deleteUserAlertConfigurations started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteUserAlertConfigurations(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserConfigurationsRepository::deleteUserAlertConfigurations result');
+        return result;
+    }
+    /**
+     * Delete user alert time windows configurations
+     * @param {DeleteAlertTimeWindowsParams} params containing information to delete user alert time windows configurations
+     * @returns Whether the user alert time windows configurations were deleted or not
+     */
+    async deleteUserAlertTimeWindows(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::deleteUserAlertTimeWindows started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteUserAlertTimeWindows(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserConfigurationsRepository::deleteUserAlertTimeWindows result');
+        return result;
+    }
+    /**
+     * Delete device alert time windows configurations
+     * @param {DeleteAlertTimeWindowsParams} params containing information to delete device alert time windows configurations
+     * @returns Whether the device alert time windows configurations were deleted or not
+     */
+    async deleteDeviceAlertTimeWindows(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::deleteDeviceAlertTimeWindows started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteDeviceAlertTimeWindows(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserConfigurationsRepository::deleteDeviceAlertTimeWindows result');
+        return result;
+    }
+    /**
+     * Update user alert time windows configurations
+     * @param {UpdateUserAlertTimeWindowsParams} params containing information to update user alert time windows configurations
+     *  - filters.configId: The user alert time windows configuration id to update, required
+     *  - values.alertConfigurationId: The alert configuration id to update, optional
+     *  - values.daysOfTheWeek: The days of the week to update, optional
+     *  - values.startTime: The start time to update, optional
+     *  - values.endTime: The end time to update, optional
+     * One of the values should be provided
+     * @returns Whether the user alert time windows configurations were updated or not
+     */
+    async updateUserAlertTimeWindows(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::updateUserAlertTimeWindows started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateUserAlertTimeWindows(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserConfigurationsRepository::updateUserAlertTimeWindows result');
+        return result;
+    }
+    /**
+     * Update device alert time windows configurations
+     * @param {UpdateDeviceAlertTimeWindowsParams} params containing information to update device alert time windows configurations
+     *  - filters.configId: The device alert time windows configuration id to update, required
+     *  - values.alertConfigurationId: The alert configuration id to update, optional
+     *  - values.daysOfTheWeek: The days of the week to update, optional
+     *  - values.startTime: The start time to update, optional
+     *  - values.endTime: The end time to update, optional
+     *  - values.filter: The filter to update, optional
+     * One of the values should be provided
+     * @returns Whether the device alert time windows configurations were updated or not
+     */
+    async updateDeviceAlertTimeWindows(params) {
+        this.logger.trace(params, 'UserConfigurationsRepository::updateDeviceAlertTimeWindows started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateDeviceAlertTimeWindows(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserConfigurationsRepository::updateDeviceAlertTimeWindows result');
+        return result;
+    }
+}

package/dist/repositories/userConfigurations/updateDeviceAlertTimeWindows.js

@@ -0,0 +1,29 @@
+import { DeviceAlertConfiguration } from '../../entities';
+export const updateDeviceAlertTimeWindows = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.configId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::updateDeviceAlertTimeWindows - missing required parameters');
+        return false;
+    }
+    if (Object.values(params?.values).every(value => value === null || value === undefined)) {
+        logger.warn({ params }, 'UserConfigurationsRepository::updateDeviceAlertTimeWindows - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userAlertConfigurationsRepository = dataSource.getRepository(DeviceAlertConfiguration);
+        const queryBuilder = userAlertConfigurationsRepository
+            .createQueryBuilder()
+            .update(DeviceAlertConfiguration)
+            .set({
+            alertConfigurationId: params?.values?.alertConfigurationId ?? undefined,
+            daysOfTheWeek: params?.values?.daysOfTheWeek ?? undefined,
+            startTime: params?.values?.startTime ?? undefined,
+            endTime: params?.values?.endTime ?? undefined,
+            filter: params?.values?.filter ?? undefined,
+            label: params?.values?.label ?? undefined,
+        })
+            .where('id = :id', { id: params?.filters?.configId });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserConfigurationsRepository::updateUserAlertConfiguration');
+};

package/dist/repositories/userConfigurations/updateUserAlertConfigurations.js

@@ -0,0 +1,46 @@
+import { UserAlertConfiguration } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateUserAlertConfigurations = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::updateUserAlertConfigurations - missing required parameters');
+        return false;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (!userIdBinaryBuffer) {
+        logger.warn({ userId: params?.filters?.userId }, 'UserConfigurationsRepository::updateUserAlertConfigurations - user id should be a valid UUID');
+        return false;
+    }
+    // at least one field to update is required
+    if (params?.values?.smsNotification == null &&
+        params?.values?.emailNotification == null &&
+        params?.values?.appNotification == null &&
+        params?.values?.pushNotification == null &&
+        !params?.values?.alertValue &&
+        !params?.values?.alertMetadata) {
+        logger.warn({ params }, 'UserConfigurationsRepository::updateUserAlertConfigurations - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userAlertConfigurationsRepository = dataSource.getRepository(UserAlertConfiguration);
+        const queryBuilder = userAlertConfigurationsRepository
+            .createQueryBuilder()
+            .update(UserAlertConfiguration)
+            .set({
+            smsNotification: params?.values?.smsNotification,
+            emailNotification: params?.values?.emailNotification,
+            appNotification: params?.values?.appNotification,
+            pushNotification: params?.values?.pushNotification,
+            alertValue: params?.values?.alertValue,
+            alertMetadata: params?.values?.alertMetadata,
+        })
+            .where('userId = :userId', { userId: userIdBinaryBuffer });
+        if (params?.filters?.alertTypeId) {
+            queryBuilder.andWhere('alertTypeId = :alertTypeId', {
+                alertTypeId: params?.filters?.alertTypeId,
+            });
+        }
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserConfigurationsRepository::updateUserAlertConfiguration');
+};