@spytecgps/nova-orm 0.0.224 → 0.0.226

package/dist/repositories/userRegistrationAttempts/getUserRegistrationAttempts.js

@@ -0,0 +1,29 @@
+import { UserRegistrationAttempt } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUserRegistrationAttempts = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.id && !params?.filters?.tempUserId) {
+        logger.warn({ params }, 'UserRegistrationAttemptsRepository::getUserRegistrationAttempts - missing required parameters');
+        return [];
+    }
+    const tempUserIdBinaryBuffer = uuidStringToBinaryBuffer(params?.filters?.tempUserId);
+    if (params?.filters?.tempUserId && !tempUserIdBinaryBuffer?.length) {
+        logger.warn({ params }, 'UserRegistrationAttemptsRepository::getUserRegistrationAttempts - temp user id should be a valid UUID');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userRegistrationAttemptsRepository = dataSource.getRepository(UserRegistrationAttempt);
+        let queryBuilder = userRegistrationAttemptsRepository.createQueryBuilder('userRegistrationAttempt');
+        if (params?.filters?.id) {
+            queryBuilder = queryBuilder.where('userRegistrationAttempt.id = :id', {
+                id: params?.filters?.id,
+            });
+        }
+        if (params?.filters?.tempUserId) {
+            queryBuilder = queryBuilder.where('userRegistrationAttempt.tempUserId = :tempUserId', {
+                tempUserId: tempUserIdBinaryBuffer,
+            });
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UserRegistrationAttemptsRepository::getUserRegistrationAttempts');
+};

package/dist/repositories/userRegistrationAttempts/index.js

@@ -0,0 +1,70 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createUserRegistrationAttempt } from './createUserRegistrationAttempt';
+import { getUserRegistrationAttempts } from './getUserRegistrationAttempts';
+import { updateUserRegistrationAttempt } from './updateUserRegistrationAttempt';
+export class UserRegistrationAttemptsRepository extends BaseRepository {
+    /**
+     * Get user registration attempts
+     * @param {GetUserRegistrationAttemptsParams} params containing information to get user registration attempts
+     * One of the following filters is required:
+     * - filters.id: The user registration attempt id
+     * - filters.tempUserId: The temp user id
+     * @returns The user registration attempts list
+     */
+    async getUserRegistrationAttempts(params) {
+        this.logger.trace(params, 'UserRegistrationAttemptsRepository::getUserRegistrationAttempts started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getUserRegistrationAttempts(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserRegistrationAttemptsRepository::getUserRegistrationAttempts result');
+        return result;
+    }
+    /**
+     * Create user registration attempt
+     * @param {CreateUserRegistrationAttemptParams} params containing information to create user registration attempt
+     * One of the following fields is required:
+     * - id: The user registration attempt id
+     * - firstName: The user first name
+     * - lastName: The user last name
+     * - email: The user email
+     * - phoneNumber: The user phone number
+     * - phoneCode: The user phone code
+     * - phoneCodeCountryId: The user phone code country id
+     * - imei: The user imei
+     * - platform: The user platform
+     * - status: The user status
+     * - tempUserId: The temp user id
+     * @returns The created user registration attempt
+     */
+    async createUserRegistrationAttempt(params) {
+        this.logger.trace(params, 'UserRegistrationAttemptsRepository::createUserRegistrationAttempt started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createUserRegistrationAttempt(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'UserRegistrationAttemptsRepository::createUserRegistrationAttempt result');
+        return result;
+    }
+    /**
+     * Update user registration attempt
+     * @param {UpdateUserRegistrationAttemptParams} params containing information to update user registration attempt
+     * The following filter is required:
+     * - filters.id: The user registration attempt id
+     * One of the following fields is required:
+     * - values.clientId: The user client id
+     * - values.userName: The user name
+     * - values.pin: The user pin
+     * - values.street: The user street
+     * - values.city: The user city
+     * - values.state: The user state
+     * - values.postalCode: The user postal code
+     * - values.country: The user country
+     * - values.countryCode: The user country code
+     * @returns True if the user registration attempt was updated, false otherwise
+     */
+    async updateUserRegistrationAttempt(params) {
+        this.logger.trace(params, 'UserRegistrationAttemptsRepository::updateUserRegistrationAttempt started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateUserRegistrationAttempt(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'UserRegistrationAttemptsRepository::updateUserRegistrationAttempt result');
+        return result;
+    }
+}

package/dist/repositories/userRegistrationAttempts/updateUserRegistrationAttempt.js

@@ -0,0 +1,40 @@
+import { UserRegistrationAttempt } from '../../entities';
+export const updateUserRegistrationAttempt = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.id) {
+        logger.warn({ params }, 'UserRegistrationAttemptsRepository::updateUserRegistrationAttempt - missing required parameters');
+        return false;
+    }
+    if (!params?.values?.clientId &&
+        !params?.values?.userName &&
+        !params?.values?.pin &&
+        !params?.values?.street &&
+        !params?.values?.city &&
+        !params?.values?.state &&
+        !params?.values?.postalCode &&
+        !params?.values?.country &&
+        !params?.values?.countryCode) {
+        logger.warn({ params }, 'UserRegistrationAttemptsRepository::updateUserRegistrationAttempt - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const userRegistrationAttemptsRepository = dataSource.getRepository(UserRegistrationAttempt);
+        const queryBuilder = userRegistrationAttemptsRepository
+            .createQueryBuilder()
+            .update(UserRegistrationAttempt)
+            .set({
+            clientId: params?.values?.clientId,
+            userName: params?.values?.userName,
+            pin: params?.values?.pin,
+            street: params?.values?.street,
+            city: params?.values?.city,
+            state: params?.values?.state,
+            postalCode: params?.values?.postalCode,
+            country: params?.values?.country,
+            countryCode: params?.values?.countryCode,
+            lastUpdatedAt: new Date(),
+        })
+            .where('id = :id', { id: params?.filters?.id });
+        const result = await queryBuilder.execute();
+        return result.affected > 0;
+    }, 'UserRegistrationAttemptsRepository::updateUserRegistrationAttempt');
+};

package/dist/repositories/users/createUser.js

@@ -0,0 +1,47 @@
+import { User } from '../../entities/user';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createUser = async (novaDataSource, params, logger) => {
+    if (!params?.id ||
+        !params?.firstName ||
+        !params?.lastName ||
+        !params?.email ||
+        !params?.userName ||
+        !params?.clientId) {
+        logger.warn({ params }, 'UsersRepository::createUser - missing required parameters');
+        return null;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.id);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'UsersRepository::createUser - user id should be a valid UUID');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const usersRepository = dataSource.getRepository(User);
+        const now = new Date();
+        const newUser = {
+            id: binaryBuffer,
+            firstName: params.firstName,
+            lastName: params.lastName,
+            companyName: params.companyName,
+            telephone: params.telephone,
+            street: params.street,
+            postalCode: params.postalCode,
+            city: params.city,
+            region: params.region,
+            email: params.email?.toLowerCase(),
+            userName: params.userName,
+            preferredUserName: params.preferredUserName,
+            status: params.status ?? 'A',
+            clientId: params.clientId,
+            pincode: params.pinCode,
+            isAdmin: params.isAdmin ?? false,
+            countryId: params.countryId,
+            telephoneCountryId: params.telephoneCountryId,
+            dataSourceTypeId: params.dataSourceTypeId,
+            emailVerified: params.emailVerified ?? true,
+            createdAt: now,
+            modifiedAt: now,
+        };
+        return await usersRepository.save(newUser);
+    }, 'UsersRepository::createUser');
+};

package/dist/repositories/users/deleteAccount.js

@@ -0,0 +1,98 @@
+import { Boundary, BoundaryEvent, Client, ClientConfiguration, Deactivation, NotificationRecipient, Trip, User, UserActivation, UserActivationDevice, UserAlertConfiguration, UserAppFeedback, UserConfiguration, UserInvitation, UserRatingRequest, UserSecurityRole, } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const deleteAccount = async (novaDataSource, params, logger) => {
+    let binaryBuffer = uuidStringToBinaryBuffer(params?.filters?.userId);
+    await novaDataSource.connect();
+    const queryRunner = novaDataSource.createQueryRunner();
+    try {
+        if (!binaryBuffer && params?.filters?.email) {
+            const usersRepository = novaDataSource.getRepository(User);
+            const user = await usersRepository
+                .createQueryBuilder()
+                .where('email = :email', { email: params.filters.email })
+                .select('id')
+                .getRawOne();
+            if (user) {
+                binaryBuffer = user.id;
+            }
+        }
+        let clientId = params.filters.clientId;
+        if (!clientId && params.filters.email) {
+            const clientsRepository = novaDataSource.getRepository(Client);
+            const client = await clientsRepository
+                .createQueryBuilder()
+                .where('email = :email', { email: params.filters.email })
+                .select('id')
+                .getRawOne();
+            if (client) {
+                clientId = client.id;
+            }
+        }
+        await queryRunner.startTransaction();
+        let clientDeleted = false;
+        if (clientId) {
+            await queryRunner.manager.delete(NotificationRecipient, { clientId });
+            await queryRunner.manager.delete(UserSecurityRole, { clientId });
+            await queryRunner.manager.delete(UserInvitation, { inviterClientId: clientId });
+            const boundaries = await queryRunner.manager
+                .createQueryBuilder()
+                .select('boundary.id')
+                .from(Boundary, 'boundary')
+                .where('boundary.clientId = :clientId', { clientId })
+                .getMany();
+            if (boundaries?.length) {
+                await queryRunner.manager
+                    .createQueryBuilder()
+                    .delete()
+                    .from(BoundaryEvent, 'boundaryEvent')
+                    .where('boundaryEvent.boundaryId IN (:ids)', {
+                    ids: boundaries.map(x => x.id),
+                })
+                    .execute();
+                await queryRunner.manager.delete(Boundary, { clientId });
+            }
+            await queryRunner.manager.delete(Trip, { clientId });
+            await queryRunner.manager.delete(ClientConfiguration, { clientId });
+            await queryRunner.manager.delete(Deactivation, { clientId });
+            const deleteClientResult = await queryRunner.manager.delete(Client, clientId);
+            clientDeleted = deleteClientResult.affected > 0;
+        }
+        let userDeleted = false;
+        if (binaryBuffer) {
+            await queryRunner.manager.delete(UserConfiguration, { userId: binaryBuffer });
+            await queryRunner.manager.delete(UserAlertConfiguration, { userId: binaryBuffer });
+            const userActivations = await queryRunner.manager
+                .createQueryBuilder()
+                .select('userActivation.id')
+                .from(UserActivation, 'userActivation')
+                .where('userActivation.userId = :userId', { userId: binaryBuffer })
+                .getMany();
+            if (userActivations?.length) {
+                await queryRunner.manager
+                    .createQueryBuilder()
+                    .delete()
+                    .from(UserActivationDevice, 'userActivationDevice')
+                    .where(`userActivationDevice.userActivationId IN (${userActivations
+                    ?.map(x => x.id)
+                    .join(',')})`)
+                    .execute();
+                await queryRunner.manager.delete(UserActivation, { userId: binaryBuffer });
+            }
+            await queryRunner.manager.delete(UserRatingRequest, { userId: binaryBuffer });
+            await queryRunner.manager.delete(UserAppFeedback, { userId: binaryBuffer });
+            const deleteUserResult = await queryRunner.manager.delete(User, { id: binaryBuffer });
+            userDeleted = deleteUserResult.affected > 0;
+        }
+        await queryRunner.commitTransaction();
+        return clientDeleted || userDeleted;
+    }
+    catch (error) {
+        await queryRunner.rollbackTransaction();
+        logger.error({ error }, 'UsersRepository::deleteAccount error');
+        throw error;
+    }
+    finally {
+        await queryRunner.release();
+        await novaDataSource.disconnect();
+    }
+};

package/dist/repositories/users/deleteUser.js

@@ -0,0 +1,22 @@
+import { User } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const deleteUser = async (novaDataSource, params, logger) => {
+    if (!params?.id) {
+        logger.warn({ params }, 'UsersRepository::deleteUser - missing required parameters');
+        return false;
+    }
+    const binaryBuffer = uuidStringToBinaryBuffer(params?.id);
+    if (!binaryBuffer?.length) {
+        logger.warn({ params }, 'UsersRepository::deleteUser - user id should be a valid UUID');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const usersRepository = dataSource.getRepository(User);
+        const result = await usersRepository
+            .createQueryBuilder('user')
+            .delete()
+            .where('id = :id', { id: binaryBuffer })
+            .execute();
+        return result.affected > 0;
+    }, 'UsersRepository::deleteUser');
+};

package/dist/repositories/users/getUserById.js

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

package/dist/repositories/users/getUserData.js

@@ -0,0 +1,66 @@
+import { User } from '../../entities';
+import { binaryBufferToUuidString } from '../../utils/uuidHelpers';
+export const getUsersData = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.imei) {
+        logger.warn({ params }, 'UsersRepository::getUsersData - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const usersRepository = dataSource.getRepository(User);
+        const query = `SELECT U.id as userId, U.telephone, U.email
+                  , UC.isMetric, coalesce (UC.timezone, '')  as timezone, UC.alertsNotificationsOn, UC.speedUnits , UC.distanceUnits
+                  , AC.alertTypeId, AC.smsNotification, AC.emailNotification, AC.alertValue, AC.pushNotification , AC.appNotification , AC.alertMetadata
+                  , D.name as deviceName, D.deviceTypeId
+                  , C.id as clientId
+                  , U.isAdmin
+                  , CO.internationalDirectDialing
+                  , ( SELECT CONCAT('[',
+                      GROUP_CONCAT( distinct case when  NR.isUserProfile = true
+                    then CONCAT('"', U.telephone, '"') else CONCAT('"', NR.recipient, '"') end SEPARATOR ','), 
+                    ']') AS JSON
+                    from notificationRecipient as NR
+                    where NR.clientId = C.id
+                    and NR.userId = U.id
+                    and  NR.notificationType = 2
+                    and NR.isEnabled = true
+                    and NR.unsubscribed = false ) as phoneNumbers
+                  , ( SELECT  CONCAT('[',
+                    GROUP_CONCAT( distinct case when  NR.isUserProfile = true
+                    then CONCAT('"', U.email, '"') else CONCAT('"', NR.recipient, '"') end SEPARATOR ','),
+                    ']') AS JSON
+                    from notificationRecipient as NR
+                    where NR.clientId = C.id
+                    and NR.userId = U.id
+                    and  NR.notificationType = 1
+                    and NR.isEnabled = true
+                    and NR.unsubscribed = false ) as emailAddresses
+                  FROM device AS D
+                  JOIN client AS C
+                  ON D.clientId = C.id
+                  JOIN user AS U
+                  ON U.clientId = C.id and U.status = 'A'
+                  JOIN userConfiguration AS UC
+                  ON UC.userId = U.id
+                  JOIN userAlertConfiguration as AC
+                  ON AC.userId = U.id
+                  JOIN alertType AS A
+                  ON A.id = AC.alertTypeId
+                  JOIN country AS CO
+                  ON CO.id = CASE WHEN(U.countryId IS NULL OR U.countryId = 0) THEN 236 ELSE U.countryId END
+                  WHERE D.imei = ?`;
+        const result = await usersRepository.query(query, [params.filters.imei]);
+        return result.map(item => ({
+            ...item,
+            userId: binaryBufferToUuidString(item.userId),
+            isAdmin: item.isAdmin === 1,
+            isMetric: item.isMetric === 1,
+            alertsNotificationOn: item.alertsNotificationsOn === 1,
+            smsNotification: item.smsNotification === 1,
+            emailNotification: item.emailNotification === 1,
+            pushNotification: item.pushNotification === 1,
+            appNotification: item.appNotification === 1,
+            phoneNumbers: item.phoneNumbers ? JSON.parse(item.phoneNumbers) : [],
+            emailAddresses: item.emailAddresses ? JSON.parse(item.emailAddresses) : [],
+        }));
+    }, 'UsersRepository::getUsersData');
+};

package/dist/repositories/users/getUsers.js

@@ -0,0 +1,49 @@
+import { User } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const getUsers = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.emailList?.length &&
+        !params?.filters?.userName &&
+        !params?.filters?.clientId &&
+        !params?.filters?.search &&
+        !params?.filters?.status) {
+        logger.warn({ params }, 'UsersRepository::getUsers - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const usersRepository = dataSource.getRepository(User);
+        let queryBuilder = usersRepository.createQueryBuilder('user');
+        if (params.filters.emailList?.length) {
+            queryBuilder = queryBuilder.where('LOWER(user.email) IN (:...emailList)', {
+                emailList: params.filters.emailList.map(email => email.trim().toLowerCase()),
+            });
+        }
+        if (params.filters.userName) {
+            queryBuilder = queryBuilder.andWhere('(LOWER(user.userName) = LOWER(:userName) OR LOWER(user.preferredUserName) = LOWER(:userName))', {
+                userName: params.filters.userName.trim(),
+            });
+        }
+        if (params.filters.clientId) {
+            queryBuilder = queryBuilder.andWhere('user.clientId = :clientId', {
+                clientId: params.filters.clientId,
+            });
+        }
+        if (params.filters.search) {
+            const binaryBuffer = uuidStringToBinaryBuffer(params.filters.search);
+            queryBuilder = queryBuilder.andWhere(`(LOWER(user.userName) = LOWER(:search) OR 
+           LOWER(user.preferredUserName) = LOWER(:search) OR 
+           LOWER(user.email) = LOWER(:search) OR 
+           user.id = :binaryBuffer)`, {
+                search: params.filters.search.trim(),
+                binaryBuffer,
+            });
+        }
+        if (params.filters.status) {
+            queryBuilder = queryBuilder.andWhere('user.status = :status', {
+                status: params.filters.status,
+            });
+        }
+        queryBuilder = queryBuilder.orderBy('user.lastname', 'DESC');
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'UsersRepository::getUsers');
+};

package/dist/repositories/users/getUsersConfigurationByImei.js

@@ -0,0 +1,29 @@
+import { User } from '../../entities';
+//User
+//User Configuration
+//Alert Configuration
+//Device (name)
+//Country (international dialing code)
+export const getUsersConfigurationByImei = async (novaDataSource, params, logger) => {
+    try {
+        await novaDataSource.connect();
+        const usersRepository = novaDataSource.getRepository(User);
+        const userConfiguration = usersRepository
+            .createQueryBuilder('user')
+            .innerJoin('user.client', 'client')
+            .innerJoinAndSelect('client.devices', 'device')
+            .innerJoinAndSelect('user.userConfiguration', 'userConfiguration')
+            .innerJoinAndSelect('user.userAlertConfiguration', 'userAlertConfiguration')
+            .innerJoinAndSelect('user.country', 'country')
+            .where('device.imei = :imei', { imei: params.filters.imei })
+            .getMany();
+        return userConfiguration;
+    }
+    catch (error) {
+        logger.error({ error }, 'UsersRepository::getUsersConfigurationByImei error');
+        throw error;
+    }
+    finally {
+        await novaDataSource.disconnect();
+    }
+};

package/dist/repositories/users/getUsersIdByPhoneAndCountryCode.js

@@ -0,0 +1,21 @@
+import { Country, User } from '../../entities';
+import { binaryBufferToUuidString } from '../../utils/uuidHelpers';
+export const getUsersIdsByPhoneAndCountryCode = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.phone || !params?.filters?.countryCode) {
+        logger.warn({ params }, 'UsersRepository::getUsersIdsByPhoneAndCountryCode - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const usersRepository = dataSource.getRepository(User);
+        let queryBuilder = usersRepository
+            .createQueryBuilder('user')
+            .innerJoin(Country, 'country', 'country.id = user.countryId')
+            .where('country.alpha2Code = :countryCode', { countryCode: params.filters.countryCode })
+            .andWhere(`user.telephone = REPLACE(:phone, country.internationalDirectDialing, '')`, {
+            phone: params.filters.phone,
+        });
+        queryBuilder = queryBuilder.select('user.id as id');
+        const result = await queryBuilder.getRawMany();
+        return result?.map(item => binaryBufferToUuidString(item.id));
+    }, 'UsersRepository::getUsersIdsByPhoneAndCountryCode');
+};

package/dist/repositories/users/getUsersWithRoles.js

@@ -0,0 +1,32 @@
+import { SecurityRole, User, UserSecurityRole } from '../../entities';
+import { mapRawEntityToEntity } from '../../utils/mapRawEntityToEntity';
+export const getUsersWithRoles = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.clientId || (!params?.filters?.status && !params?.filters?.roleId)) {
+        logger.warn({ params }, 'UsersRepository::getUsersWithRoles - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const usersRepository = dataSource.getRepository(User);
+        let queryBuilder = usersRepository
+            .createQueryBuilder('user')
+            .innerJoin(UserSecurityRole, 'userSecurityRole', 'userSecurityRole.userId = user.id')
+            .innerJoin(SecurityRole, 'securityRole', 'securityRole.id = userSecurityRole.securityRoleId')
+            .where('user.clientId = :clientId', {
+            clientId: params.filters.clientId,
+        });
+        if (params.filters.roleId) {
+            queryBuilder = queryBuilder.andWhere('securityRole.id = :roleId', {
+                roleId: params.filters.roleId,
+            });
+        }
+        if (params.filters.status) {
+            queryBuilder = queryBuilder.andWhere('user.status = :status', {
+                status: params.filters.status,
+            });
+        }
+        queryBuilder = queryBuilder.addSelect('securityRole.name', 'role');
+        const usersWithRole = await queryBuilder.getRawMany();
+        const result = usersWithRole.map(item => mapRawEntityToEntity(item, 'user_'));
+        return result;
+    }, 'UsersRepository::getUsersWithRoles');
+};