@spytecgps/nova-orm 0.0.224 → 0.0.226

package/dist/repositories/userConfigurations/updateUserAlertTimeWindows.js

@@ -0,0 +1,28 @@
+import { AlertTimeWindowConfiguration } from '../../entities';
+export const updateUserAlertTimeWindows = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.configId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::updateUserAlertConfigurations - missing required parameters');
+        return false;
+    }
+    if (Object.values(params?.values).every(value => value === null || value === undefined)) {
+        logger.warn({ params }, 'UserConfigurationsRepository::updateUserAlertConfigurations - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userAlertConfigurationsRepository = dataSource.getRepository(AlertTimeWindowConfiguration);
+        const queryBuilder = userAlertConfigurationsRepository
+            .createQueryBuilder()
+            .update(AlertTimeWindowConfiguration)
+            .set({
+            alertConfigurationId: params?.values?.alertConfigurationId ?? undefined,
+            daysOfTheWeek: params?.values?.daysOfTheWeek ?? undefined,
+            startTime: params?.values?.startTime ?? undefined,
+            endTime: params?.values?.endTime ?? 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/updateUserConfiguration.js

@@ -0,0 +1,49 @@
+import { UserConfiguration } from '../../entities/userConfiguration';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateUserConfiguration = async (novaDataSource, params, logger) => {
+    // userId filter is required
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'UserConfigurationsRepository::updateUserConfiguration - missing required parameters');
+        return false;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (!userIdBinaryBuffer) {
+        logger.warn({ userId: params?.filters?.userId }, 'UserConfigurationsRepository::updateUserConfiguration - user id should be a valid UUID');
+        return false;
+    }
+    // at least one field to update is required
+    if (!params?.values?.timezone &&
+        !params?.values?.defaultMapLayer &&
+        !params?.values?.speedUnits &&
+        !params?.values?.distanceUnits &&
+        params?.values?.alertsNotificationsOn == null &&
+        !params?.values?.dataSourceTypeId &&
+        !params?.values?.homepage &&
+        !params?.values?.temperatureUnits &&
+        !params?.values?.addressFormat) {
+        logger.warn({ params }, 'UserConfigurationsRepository::updateUserConfiguration - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userConfigurationsRepository = dataSource.getRepository(UserConfiguration);
+        const now = new Date();
+        const queryBuilder = userConfigurationsRepository
+            .createQueryBuilder()
+            .update(UserConfiguration)
+            .set({
+            timezone: params.values.timezone,
+            defaultMapLayer: params.values.defaultMapLayer,
+            speedUnits: params.values.speedUnits,
+            distanceUnits: params.values.distanceUnits,
+            alertsNotificationsOn: params.values.alertsNotificationsOn,
+            dataSourceTypeId: params.values.dataSourceTypeId,
+            homepage: params.values.homepage,
+            temperatureUnits: params.values.temperatureUnits,
+            modifiedAt: now,
+            addressFormat: params.values.addressFormat,
+        })
+            .where('userId = :userId', { userId: userIdBinaryBuffer });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserConfigurationsRepository::updateUserConfiguration');
+};

package/dist/repositories/userDataDeletionRequests/createUserDataDeletionRequest.js

@@ -0,0 +1,28 @@
+import { UserDataDeletionRequest } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserDataDeletionRequest = async (novaDataSource, params, logger) => {
+    if (!params?.userId || !params?.clientId || !params?.email || !params?.userSecurityRoleName) {
+        logger.warn({ params }, 'UserDataDeletionRequestsRepository::createUserDataDeletionRequest - missing required parameters');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ userId: params?.userId }, 'UserDataDeletionRequestsRepository::createUserDataDeletionRequest - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userDataDeletionRequestsRepository = dataSource.getRepository(UserDataDeletionRequest);
+        const now = new Date();
+        const newUserDataDeletionRequest = {
+            id: params?.id,
+            userId: userIdBinaryBuffer,
+            clientId: params.clientId,
+            email: params.email,
+            userSecurityRoleName: params.userSecurityRoleName,
+            status: params.status,
+            createdAt: now,
+            modifiedAt: now,
+        };
+        return await userDataDeletionRequestsRepository.save(newUserDataDeletionRequest);
+    }, 'UserDataDeletionRequestsRepository::createUserDataDeletionRequest');
+};

package/dist/repositories/userDataDeletionRequests/getUserDataDeletionRequest.js

@@ -0,0 +1,29 @@
+import { UserDataDeletionRequest } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserDataDeletionRequest = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId && !params?.filters?.id) {
+        logger.warn({ params }, 'UserDataDeletionRequestsRepository::getUserDataDeletionRequest - missing required parameters');
+        return null;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (params?.filters?.userId && !binaryBuffer?.length) {
+        logger.warn({ params }, 'UserDataDeletionRequestsRepository::getUserDataDeletionRequest - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userDataDeletionRequestsRepository = dataSource.getRepository(UserDataDeletionRequest);
+        let queryBuilder = userDataDeletionRequestsRepository.createQueryBuilder('userDataDeletionRequest');
+        if (params?.filters?.id) {
+            queryBuilder = queryBuilder.where('userDataDeletionRequest.id = :id', {
+                id: params?.filters?.id,
+            });
+        }
+        if (params?.filters?.userId) {
+            queryBuilder = queryBuilder.where('userDataDeletionRequest.userId = :userId', {
+                userId: binaryBuffer,
+            });
+        }
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'UserDataDeletionRequestsRepository::getUserDataDeletionRequest');
+};

package/dist/repositories/userDataDeletionRequests/index.js

@@ -0,0 +1,66 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createUserDataDeletionRequest } from './createUserDataDeletionRequest';
+import { getUserDataDeletionRequest } from './getUserDataDeletionRequest';
+import { removeUserDataDeletionRequest } from './removeUserDataDeletionRequest';
+import { updateUserDataDeletionRequest } from './updateUserDataDeletionRequest';
+export class UserDataDeletionRequestsRepository extends BaseRepository {
+    /**
+     * Get user data deletion request
+     * @param {GetUserDataDeletionRequestParams} params containing information to get a user data deletion request
+     * - filters.userId: The user id
+     * @returns The user data deletion request information
+     */
+    async getUserDataDeletionRequest(params) {
+        this.logger.trace(params, 'UserDataDeletionRequestsRepository::getUserDataDeletionRequest started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserDataDeletionRequest(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserDataDeletionRequestsRepository::getUserDataDeletionRequest result');
+        return result;
+    }
+    /**
+     * Create user data deletion request
+     * @param {CreateUserDataDeletionRequestParams} params containing information to create a user data deletion request
+     * - id: The id, optional. If not provided, it will be generated
+     * - userId: The user id, required
+     * - clientId: The client id, required
+     * - userSecurityRoleName: The user security role name, required
+     * - email: The email, required
+     * - status: The status, optional
+     * @returns The created user data deletion request information
+     */
+    async createUserDataDeletionRequest(params) {
+        this.logger.trace(params, 'UserDataDeletionRequestsRepository::createUserDataDeletionRequest started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserDataDeletionRequest(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserDataDeletionRequestsRepository::createUserDataDeletionRequest result');
+        return result;
+    }
+    /**
+     * Update user data deletion request
+     * @param {UpdateUserDataDeletionRequestParams} params containing information to update a user data deletion request
+     * - filters.userId: The user id
+     * - values.status: The status
+     * @returns Whether the user data deletion request was updated
+     */
+    async updateUserDataDeletionRequest(params) {
+        this.logger.trace(params, 'UserDataDeletionRequestsRepository::updateUserDataDeletionRequest started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateUserDataDeletionRequest(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserDataDeletionRequestsRepository::updateUserDataDeletionRequest result');
+        return result;
+    }
+    /**
+     * Remove user data deletion request
+     * @param {RemoveUserDataDeletionRequestParams} params containing information to remove a user data deletion request
+     * - filters.id: The user data deletion request id
+     * @returns Whether the user data deletion request was removed
+     */
+    async removeUserDataDeletionRequest(params) {
+        this.logger.trace(params, 'UserDataDeletionRequestsRepository::removeUserDataDeletionRequest started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await removeUserDataDeletionRequest(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserDataDeletionRequestsRepository::removeUserDataDeletionRequest result');
+        return result;
+    }
+}

package/dist/repositories/userDataDeletionRequests/removeUserDataDeletionRequest.js

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

package/dist/repositories/userDataDeletionRequests/updateUserDataDeletionRequest.js

@@ -0,0 +1,38 @@
+import { UserDataDeletionRequest } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateUserDataDeletionRequest = async (novaDataSource, params, logger) => {
+    // at least one filter is required
+    if (!params?.filters?.userId && !params?.filters?.id) {
+        logger.warn({ params }, 'UserDataDeletionRequestsRepository::updateUserDataDeletionRequest - missing required parameters');
+        return false;
+    }
+    // values is required
+    if (!params?.values?.status) {
+        logger.warn({ params }, 'UserDataDeletionRequestsRepository::updateUserDataDeletionRequest - missing required parameters');
+        return false;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (params?.filters?.userId && !userIdBinaryBuffer?.length) {
+        logger.warn({ userId: params?.filters?.userId }, 'UserDataDeletionRequestsRepository::updateUserDataDeletionRequest - user id should be a valid UUID');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userDataDeletionRequestsRepository = dataSource.getRepository(UserDataDeletionRequest);
+        const now = new Date();
+        let queryBuilder = userDataDeletionRequestsRepository
+            .createQueryBuilder()
+            .update(UserDataDeletionRequest)
+            .set({
+            status: params?.values?.status,
+            modifiedAt: now,
+        });
+        if (params?.filters?.id) {
+            queryBuilder = queryBuilder.where('id = :id', { id: params?.filters?.id });
+        }
+        if (params?.filters?.userId) {
+            queryBuilder = queryBuilder.andWhere('userId = :userId', { userId: userIdBinaryBuffer });
+        }
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserDataDeletionRequestsRepository::updateUserDataDeletionRequest');
+};

package/dist/repositories/userInvitations/createUserInvitation.js

@@ -0,0 +1,43 @@
+import { UserInvitation } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserInvitation = async (novaDataSource, params, logger) => {
+    if (!params?.id ||
+        !params?.inviterClientId ||
+        !params?.inviterUserId ||
+        !params?.inviteeEmail ||
+        !params?.inviteeSecurityRoleId ||
+        !params?.statusId) {
+        logger.warn({ params }, 'UsersRepository::createUserInvitation - missing required parameters');
+        return null;
+    }
+    const invitationIdBinaryBuffer = uuidStringToBinaryBuffer(params?.id);
+    if (!invitationIdBinaryBuffer?.length) {
+        logger.warn({ invitationId: params?.id }, 'UsersRepository::createUserInvitation - user invitation id should be a valid UUID');
+        return null;
+    }
+    const inviterUserIdBinaryBuffer = uuidStringToBinaryBuffer(params?.inviterUserId);
+    if (!inviterUserIdBinaryBuffer?.length) {
+        logger.warn({ inviterUserId: params?.inviterUserId }, 'UsersRepository::createUserInvitation - inviter user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userInvitationsRepository = dataSource.getRepository(UserInvitation);
+        const now = new Date();
+        const newUserInvitation = {
+            id: invitationIdBinaryBuffer,
+            inviterClientId: params.inviterClientId,
+            inviterUserId: inviterUserIdBinaryBuffer,
+            inviteeEmail: params.inviteeEmail,
+            inviteeSecurityRoleId: params.inviteeSecurityRoleId,
+            statusId: params.statusId,
+            trackerImeis: params.trackerImeis,
+            trackerAccess: params.trackerAccess,
+            minAccessDate: params.minAccessDate,
+            boundaries: params.boundaries,
+            boundaryAccess: params.boundaryAccess,
+            createdAt: now,
+            modifiedAt: now,
+        };
+        return await userInvitationsRepository.save(newUserInvitation);
+    }, 'UsersRepository::createUserInvitation');
+};

package/dist/repositories/userInvitations/getUserInvitationById.js

@@ -0,0 +1,22 @@
+import { UserInvitation } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserInvitationById = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.id) {
+        logger.warn({ params }, 'UserInvitationsRepository::getUserInvitationById - missing required parameters');
+        return null;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.filters?.id);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'UserInvitationsRepository::getUserInvitationById - user invitation id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userInvitationsRepository = dataSource.getRepository(UserInvitation);
+        let queryBuilder = userInvitationsRepository.createQueryBuilder('userInvitation');
+        queryBuilder = queryBuilder.where('userInvitation.id = :id', {
+            id: binaryBuffer,
+        });
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'UserInvitationsRepository::getUserInvitationById');
+};

package/dist/repositories/userInvitations/getUserInvitations.js

@@ -0,0 +1,31 @@
+import { UserInvitation } from '../../entities';
+export const getUserInvitations = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.inviteeEmails?.length &&
+        !params?.filters?.inviterClientId &&
+        !params?.filters?.statusList?.length) {
+        logger.warn({ params }, 'UserInvitationsRepository::getUserInvitations - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userInvitationsRepository = dataSource.getRepository(UserInvitation);
+        let queryBuilder = userInvitationsRepository.createQueryBuilder('userInvitation');
+        if (params?.filters?.inviteeEmails?.length) {
+            queryBuilder = queryBuilder.andWhere('LOWER(userInvitation.inviteeEmail) IN (:...inviteeEmails)', {
+                inviteeEmails: params.filters.inviteeEmails.map(email => email.trim().toLowerCase()),
+            });
+        }
+        if (params?.filters?.inviterClientId) {
+            queryBuilder = queryBuilder.andWhere('userInvitation.inviterClientId = :inviterClientId', {
+                inviterClientId: params.filters.inviterClientId,
+            });
+        }
+        if (params?.filters?.statusList?.length) {
+            queryBuilder = queryBuilder.andWhere('userInvitation.statusId IN (:...statusList)', {
+                statusList: params.filters.statusList,
+            });
+        }
+        queryBuilder = queryBuilder.orderBy('userInvitation.createdAt', 'DESC');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UserInvitationsRepository::getUserInvitations');
+};

package/dist/repositories/userInvitations/index.js

@@ -0,0 +1,82 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createUserInvitation } from './createUserInvitation';
+import { getUserInvitationById } from './getUserInvitationById';
+import { getUserInvitations } from './getUserInvitations';
+import { updateUserInvitation } from './updateUserInvitation';
+export class UserInvitationsRepository extends BaseRepository {
+    /**
+     * Get user invitation by id
+     * @param {GetUserInvitationByIdParams} params containing information to get a user invitation by id
+     * - filters.id: The user invitation id
+     * @returns The user invitation information
+     */
+    async getUserInvitationById(params) {
+        this.logger.trace(params, 'UserInvitationsRepository::getUserInvitationById started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserInvitationById(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserInvitationsRepository::getUserInvitationById result');
+        return result;
+    }
+    /**
+     * Get user invitations with filters
+     * @param {GetUserInvitationsParams} params containing information to get user invitations
+     * - filters.inviterClientId: The inviter client id
+     * - filters.inviteeEmails: The array of invitee emails to filter by
+     * - filters.statusList: The array of status list to filter by
+     * @returns The user invitations list
+     */
+    async getUserInvitations(params) {
+        this.logger.trace(params, 'UserInvitationsRepository::getUserInvitations started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserInvitations(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserInvitationsRepository::getUserInvitations result');
+        return result;
+    }
+    /**
+     * Update user invitation
+     * @param {UpdateUserInvitationParams} params containing information to update a user invitation
+     * - filters.id: The user invitation id
+     * At least one value must be provided:
+     * - values.statusId: The status id, optional
+     * - values.inviteeUserId: The invitee user id, optional
+     * - values.inviteeEmail: The invitee email, optional
+     * - values.inviteeSecurityRoleId: The invitee security role id, optional
+     * - values.trackerImeis: The tracker imeis, optional
+     * - values.trackerAccess: The tracker access, optional
+     * - values.minAccessDate: The min access date, optional
+     * - values.boundaries: The boundaries, optional
+     * - values.boundaryAccess: The boundary access, optional
+     * @returns Whether the user invitation was updated or not
+     */
+    async updateUserInvitation(params) {
+        this.logger.trace(params, 'UserInvitationsRepository::updateUserInvitation started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateUserInvitation(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserInvitationsRepository::updateUserInvitation result');
+        return result;
+    }
+    /**
+     * Create user invitation
+     * @param {CreateUserInvitationParams} params containing information to create a user invitation
+     * - id: The user invitation id, required
+     * - inviterClientId: The inviter client id, required
+     * - inviterUserId: The inviter user id, required
+     * - inviteeEmail: The invitee email, required
+     * - inviteeSecurityRoleId: The invitee security role id, required
+     * - statusId: The status id, required
+     * - trackerImeis: The tracker imeis, optional
+     * - trackerAccess: The tracker access, optional
+     * - minAccessDate: The min access date, optional
+     * - boundaries: The boundaries, optional
+     * - boundaryAccess: The boundary access, optional
+     * @returns The created user invitation
+     */
+    async createUserInvitation(params) {
+        this.logger.trace(params, 'UserInvitationsRepository::createUserInvitation started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserInvitation(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserInvitationsRepository::createUserInvitation result');
+        return result;
+    }
+}

package/dist/repositories/userInvitations/updateUserInvitation.js

@@ -0,0 +1,50 @@
+import { UserInvitation } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateUserInvitation = async (novaDataSource, params, logger) => {
+    // filter is required
+    if (!params?.filters?.id) {
+        logger.warn({ params }, 'UsersRepository::updateUserInvitation - missing required parameters');
+        return false;
+    }
+    const invitationIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.id);
+    if (!invitationIdBinaryBuffer?.length) {
+        logger.warn({ invitationId: params?.filters?.id }, 'UsersRepository::updateUserInvitation - user invitation id should be a valid UUID');
+        return false;
+    }
+    const inviteeUserIdBinaryBuffer = uuidStringToBinaryBuffer(params?.values?.inviteeUserId);
+    // at least one field to update is required
+    if (!params?.values?.statusId &&
+        !inviteeUserIdBinaryBuffer?.length &&
+        !params?.values?.inviteeEmail &&
+        !params?.values?.inviteeSecurityRoleId &&
+        !params?.values?.trackerImeis &&
+        !params?.values?.trackerAccess &&
+        !params?.values?.minAccessDate &&
+        !params?.values?.boundaries &&
+        !params?.values?.boundaryAccess) {
+        logger.warn({ params }, 'UsersRepository::updateUserInvitation - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userInvitationsRepository = dataSource.getRepository(UserInvitation);
+        const now = new Date();
+        let queryBuilder = userInvitationsRepository
+            .createQueryBuilder()
+            .update(UserInvitation)
+            .set({
+            statusId: params?.values?.statusId,
+            inviteeUserId: inviteeUserIdBinaryBuffer,
+            inviteeEmail: params?.values?.inviteeEmail,
+            inviteeSecurityRoleId: params?.values?.inviteeSecurityRoleId,
+            trackerImeis: params?.values?.trackerImeis,
+            trackerAccess: params?.values?.trackerAccess,
+            minAccessDate: params?.values?.minAccessDate,
+            boundaries: params?.values?.boundaries,
+            boundaryAccess: params?.values?.boundaryAccess,
+            modifiedAt: now,
+        });
+        queryBuilder = queryBuilder.where('id = :id', { id: invitationIdBinaryBuffer });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UsersRepository::updateUserInvitation');
+};

package/dist/repositories/userRatingRequests/createUserRatingRequest.js

@@ -0,0 +1,34 @@
+import { UserRatingRequest } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserRatingRequest = async (novaDataSource, params, logger) => {
+    if (!params?.userId ||
+        !params?.clientId ||
+        !params?.deviceManufacturer ||
+        !params?.deviceOs ||
+        !params.deviceOsVersion ||
+        !params?.appVersion) {
+        logger.warn({ params }, 'UserRatingRequestsRepository::createUserRatingRequest - missing required parameters');
+        return null;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params?.userId);
+    if (!userIdBinaryBuffer?.length) {
+        logger.warn({ userId: params?.userId }, 'UserRatingRequestsRepository::createUserRatingRequest - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userRatingRequestsRepository = dataSource.getRepository(UserRatingRequest);
+        const newUserRatingRequest = {
+            id: params?.id,
+            userId: userIdBinaryBuffer,
+            clientId: params.clientId,
+            deviceManufacturer: params.deviceManufacturer,
+            deviceOs: params.deviceOs,
+            deviceOsVersion: params.deviceOsVersion,
+            appVersion: params.appVersion,
+            requestDate: params.requestDate,
+            amazonRequestDate: params.amazonRequestDate,
+            deviceIdentifierKey: params.deviceIdentifierKey,
+        };
+        return await userRatingRequestsRepository.save(newUserRatingRequest);
+    }, 'UserRatingRequestsRepository::createUserRatingRequest');
+};

package/dist/repositories/userRatingRequests/getUserRatingRequests.js

@@ -0,0 +1,23 @@
+import { UserRatingRequest } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserRatingRequests = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.userId) {
+        logger.warn({ params }, 'UserRatingRequestsRepository::getUserRatingRequests - missing required parameters');
+        return [];
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'UserRatingRequestsRepository::getUserRatingRequests - user id should be a valid UUID');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userRatingRequestsRepository = dataSource.getRepository(UserRatingRequest);
+        let queryBuilder = userRatingRequestsRepository.createQueryBuilder('userRatingRequest');
+        queryBuilder = queryBuilder.where('userRatingRequest.userId = :userId', {
+            userId: binaryBuffer,
+        });
+        queryBuilder = queryBuilder.orderBy('userRatingRequest.requestDate', 'DESC');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UserRatingRequestsRepository::getUserRatingRequests');
+};

package/dist/repositories/userRatingRequests/index.js

@@ -0,0 +1,41 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createUserRatingRequest } from './createUserRatingRequest';
+import { getUserRatingRequests } from './getUserRatingRequests';
+export class UserRatingRequestsRepository extends BaseRepository {
+    /**
+     * Get user rating requests
+     * @param {GetUserRatingRequestsParams} params containing information to get a user rating requests
+     * - filters.userId: The user id
+     * @returns The user rating requests list
+     */
+    async getUserRatingRequests(params) {
+        this.logger.trace(params, 'UserRatingRequestsRepository::getUserRatingRequests started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserRatingRequests(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserRatingRequestsRepository::getUserRatingRequests result');
+        return result;
+    }
+    /**
+     * Create user rating request
+     * @param {CreateUserRatingRequestParams} params containing information to create a user rating request
+     * - id: The id, optional. If not provided, it will be generated
+     * - userId: The user id, required
+     * - clientId: The client id, required
+     * - deviceManufacturer: The device manufacturer, required
+     * - deviceOs: The device os, required
+     * - deviceOsVersion: The device os version, required
+     * - appVersion: The app version, required
+     * - requestDate: The request date, optional
+     * - amazonRequestDate: The amazon request date, optional
+     * - deviceIdentifierKey: The device identifier key, optional
+     * @returns The created user rating request information
+     */
+    async createUserRatingRequest(params) {
+        this.logger.trace(params, 'UserRatingRequestsRepository::createUserRatingRequest started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserRatingRequest(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserRatingRequestsRepository::createUserRatingRequest result');
+        return result;
+    }
+}

package/dist/repositories/userRegistrationAttempts/createUserRegistrationAttempt.js

@@ -0,0 +1,40 @@
+import { UserRegistrationAttempt } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUserRegistrationAttempt = async (novaDataSource, params, logger) => {
+    if (!params?.firstName &&
+        !params?.lastName &&
+        !params?.email &&
+        !params?.phoneNumber &&
+        !params?.phoneCode &&
+        !params?.phoneCodeCountryId &&
+        !params?.imei &&
+        !params?.platform &&
+        !params?.status &&
+        !params?.tempUserId) {
+        logger.warn({ params }, 'UserRegistrationAttemptsRepository::createUserRegistrationAttempt - missing required parameters');
+        return null;
+    }
+    const tempUserIdBinaryBuffer = uuidStringToBinaryBuffer(params?.tempUserId);
+    if (params?.tempUserId && !tempUserIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'UserRegistrationAttemptsRepository::getUserRegistrationAttempts - temp user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userRegistrationAttemptsRepository = dataSource.getRepository(UserRegistrationAttempt);
+        const newUserRegistrationAttempt = {
+            id: params?.id,
+            firstName: params?.firstName,
+            lastName: params?.lastName,
+            email: params?.email,
+            phoneNumber: params?.phoneNumber,
+            phoneCode: params?.phoneCode,
+            phoneCodeCountryId: params?.phoneCodeCountryId,
+            imei: params?.imei,
+            platform: params?.platform,
+            status: params?.status,
+            tempUserId: tempUserIdBinaryBuffer,
+            createdAt: new Date(),
+        };
+        return await userRegistrationAttemptsRepository.save(newUserRegistrationAttempt);
+    }, 'UserRegistrationAttemptsRepository::createUserRegistrationAttempt');
+};