@spytecgps/nova-orm 0.0.223 → 0.0.225

package/dist/repositories/boundaries/updateBoundary.js

@@ -0,0 +1,53 @@
+import { Boundary } from '../../entities';
+export const updateBoundary = async (novaDataSource, params, logger) => {
+    // boundaryId is required
+    if (!params?.filters?.boundaryId) {
+        logger.warn({ params }, 'BoundariesRepository::updateBoundary - missing required parameters');
+        return false;
+    }
+    // status
+    const status = params?.values?.status > 0 && params?.values?.status < 4 ? params.values.status : undefined;
+    // radius
+    let buffer = params?.values?.buffer;
+    if (buffer) {
+        const bufferFloat = parseFloat(params.values.buffer);
+        if (Number.isNaN(bufferFloat)) {
+            buffer = undefined;
+        }
+    }
+    // at least one field to update is required
+    if (!params?.values?.name &&
+        !params?.values?.type &&
+        !params?.values?.location &&
+        !buffer &&
+        !params?.values?.radiusDisplayUnit &&
+        !params?.values?.color &&
+        !params?.values?.geometry &&
+        !status &&
+        !params?.values?.area) {
+        logger.warn({ params }, 'BoundariesRepository::updateBoundary - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundariesRepository = dataSource.getRepository(Boundary);
+        const now = new Date();
+        const result = await boundariesRepository
+            .createQueryBuilder()
+            .update(Boundary)
+            .set({
+            name: params.values.name,
+            type: params.values.type,
+            modifiedBy: params.values.modifiedBy,
+            location: params.values.location,
+            buffer,
+            radiusDisplayUnit: params.values.radiusDisplayUnit,
+            color: params.values.color,
+            geometry: params.values.geometry,
+            status,
+            modifiedAt: now,
+        })
+            .where('id = :id', { id: params.filters.boundaryId })
+            .execute();
+        return result.affected > 0;
+    }, 'BoundariesRepository::updateBoundary');
+};

package/dist/repositories/boundaries/upsertBoundaryEvent.js

@@ -0,0 +1,23 @@
+import { BoundaryEvent } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const upsertBoundaryEvent = async (novaDataSource, params, logger) => {
+    if (!params?.id || !params?.boundaryId || !params?.deviceId || !params?.imei) {
+        logger.warn({ params }, 'BoundariesRepository::upsertBoundaryEvent missing required parameters');
+        return false;
+    }
+    const userIdBinaryBuffer = uuidStringToBinaryBuffer(params.userId);
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const boundaryEventRepository = dataSource.getRepository(BoundaryEvent);
+        const now = new Date();
+        const boundaryEvent = {
+            ...params,
+            userId: userIdBinaryBuffer,
+            createdAt: params.createdAt ?? now,
+            modifiedAt: params.modifiedAt ?? now,
+        };
+        const result = await boundaryEventRepository.upsert(boundaryEvent, {
+            conflictPaths: ['id'],
+        });
+        return result?.raw?.affectedRows > 0;
+    }, 'BoundariesRepository::upsertBoundaryEvent');
+};

package/dist/repositories/clients/createClient.js

@@ -0,0 +1,35 @@
+import { Client } from '../../entities';
+import { HapnClientType } from '../../types/enums';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const createClient = async (novaDataSource, params, logger) => {
+    if (!params?.name || !params?.email || !params?.uuid) {
+        logger.warn({ params }, 'ClientsRepository::createClient - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientsRepository = dataSource.getRepository(Client);
+        const now = new Date();
+        const newClient = {
+            id: params.clientId,
+            name: params.name,
+            email: params.email,
+            clientTypeId: params.clientTypeId ?? HapnClientType.b2c,
+            createdAt: now,
+            modifiedAt: now,
+            createdBy: 0,
+            modifiedBy: 0,
+            uuid: uuidStringToBinaryBuffer(params.uuid),
+            dataSourceTypeId: params.dataSourceTypeId,
+            sievaUserName: params.sievaUserName,
+            sievaBatchId: params.sievaBatchId,
+            salesforceId: params.salesforceId,
+            accumaticaId: params.accumaticaId,
+            expirationDate: params.expirationDate,
+            useType: params.useType,
+            btCustomerId: params.btCustomerId,
+            activationCampaign: params.activationCampaign,
+            organizationId: params.organizationId,
+        };
+        return await clientsRepository.save(newClient);
+    }, 'ClientsRepository::createClient');
+};

package/dist/repositories/clients/createClientConfiguration.js

@@ -0,0 +1,18 @@
+import { ClientConfiguration } from '../../entities';
+export const createClientConfiguration = async (novaDataSource, params, logger) => {
+    if (!params?.clientId) {
+        logger.warn({ params }, 'ClientsRepository::createClientConfiguration - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientConfigurationRepository = dataSource.getRepository(ClientConfiguration);
+        const newClientConfiguration = {
+            clientId: params.clientId,
+            movementTripThreshold: params.movementTripThreshold,
+            stopTripThreshold: params.stopTripThreshold,
+            mapUpdateMode: params.mapUpdateMode,
+            maxUsersAllowed: params.maxUsersAllowed,
+        };
+        return await clientConfigurationRepository.save(newClientConfiguration);
+    }, 'ClientsRepository::createClientConfiguration');
+};

package/dist/repositories/clients/createCustomerAttribute.js

@@ -0,0 +1,16 @@
+import { CustomerAttribute } from '../../entities/customerAttribute';
+export const createCustomerAttribute = async (novaDataSource, params, logger) => {
+    if (!params?.clientId) {
+        logger.warn({ params }, 'ClientsRepository::createCustomerAttribute - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientConfigurationRepository = dataSource.getRepository(CustomerAttribute);
+        const newCustomerAttribute = {
+            clientId: params.clientId,
+            enterprise: params.enterprise,
+            maintenanceModule: params.maintenanceModule,
+        };
+        return await clientConfigurationRepository.save(newCustomerAttribute);
+    }, 'ClientsRepository::createCustomerAttribute');
+};

package/dist/repositories/clients/deleteClientAndConfiguration.js

@@ -0,0 +1,25 @@
+import { Client, ClientConfiguration } from '../../entities';
+export const deleteClientAndConfiguration = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId) {
+        logger.warn({ params }, 'ClientsRepository::deleteClientAndConfiguration - missing required parameters');
+        return false;
+    }
+    await novaDataSource.connect();
+    const queryRunner = novaDataSource.createQueryRunner();
+    try {
+        await queryRunner.startTransaction();
+        await queryRunner.manager.delete(ClientConfiguration, params.filters.clientId);
+        const deleteResult = await queryRunner.manager.delete(Client, params.filters.clientId);
+        await queryRunner.commitTransaction();
+        return deleteResult.affected > 0;
+    }
+    catch (error) {
+        await queryRunner.rollbackTransaction();
+        logger.error({ error }, 'ClientsRepository::deleteClientAndConfigurations error');
+        throw error;
+    }
+    finally {
+        await queryRunner.release();
+        await novaDataSource.disconnect();
+    }
+};

package/dist/repositories/clients/getClient.js

@@ -0,0 +1,32 @@
+import { Client } from '../../entities';
+export const getClient = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId && !params.filters.email) {
+        logger.warn({ params }, 'ClientsRepository::getClient - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientsRepository = dataSource.getRepository(Client);
+        let queryBuilder = clientsRepository.createQueryBuilder('client').comment(`test=value`);
+        if (params.projectionOptions?.withCustomerAttribute) {
+            queryBuilder = queryBuilder.leftJoinAndSelect('client.customerAttribute', 'customerAttribute');
+        }
+        if (params.projectionOptions?.withOrganization) {
+            queryBuilder = queryBuilder.leftJoinAndSelect('client.organization', 'organization');
+        }
+        if (params.filters.clientId) {
+            queryBuilder = queryBuilder.where('client.id = :id', {
+                id: params.filters.clientId,
+            });
+        }
+        if (params.filters.email) {
+            queryBuilder = queryBuilder.andWhere('LOWER(client.email) = LOWER(:email)', {
+                email: params.filters.email,
+            });
+        }
+        const client = await queryBuilder
+            .leftJoinAndSelect('client.clientType', 'clientType')
+            .select()
+            .getOne();
+        return client;
+    }, 'ClientsRepository::getClient');
+};

package/dist/repositories/clients/getClientConfiguration.js

@@ -0,0 +1,14 @@
+import { ClientConfiguration } from '../../entities';
+export const getClientConfiguration = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId) {
+        logger.warn({ params }, 'ClientsRepository::getClientConfiguration - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientConfigurationRepository = dataSource.getRepository(ClientConfiguration);
+        const clientConfiguration = await clientConfigurationRepository.findOne({
+            where: { clientId: params.filters.clientId },
+        });
+        return clientConfiguration;
+    }, 'ClientsRepository::getClientConfiguration');
+};

package/dist/repositories/clients/getClients.js

@@ -0,0 +1,26 @@
+import { Client } from '../../entities';
+export const getClients = async (novaDataSource, params, logger) => {
+    if (!params.filters.email) {
+        logger.warn({ params }, 'ClientsRepository::getClients - missing required parameters');
+        return [];
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientsRepository = dataSource.getRepository(Client);
+        let queryBuilder = clientsRepository
+            .createQueryBuilder('client')
+            .where('LOWER(client.email) = LOWER(:email)', {
+            email: params.filters.email,
+        });
+        if (params.projectionOptions?.withCustomerAttribute) {
+            queryBuilder = queryBuilder.leftJoinAndSelect('client.customerAttribute', 'customerAttribute');
+        }
+        if (params.projectionOptions?.withOrganization) {
+            queryBuilder = queryBuilder.leftJoinAndSelect('client.organization', 'organization');
+        }
+        const clients = await queryBuilder
+            .leftJoinAndSelect('client.clientType', 'clientType')
+            .select()
+            .getMany();
+        return clients;
+    }, 'ClientsRepository::getClients');
+};

package/dist/repositories/clients/getCustomerAttribute.js

@@ -0,0 +1,14 @@
+import { CustomerAttribute } from '../../entities';
+export const getCustomerAttribute = async (novaDataSource, params, logger) => {
+    if (!params.filters.clientId) {
+        logger.warn({ params }, 'ClientsRepository::getCustomerAttribute - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientConfigurationRepository = dataSource.getRepository(CustomerAttribute);
+        const clientConfiguration = await clientConfigurationRepository.findOne({
+            where: { clientId: params.filters.clientId },
+        });
+        return clientConfiguration;
+    }, 'ClientsRepository::getCustomerAttribute');
+};

package/dist/repositories/clients/index.js

@@ -0,0 +1,192 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { createClient } from './createClient';
+import { createClientConfiguration } from './createClientConfiguration';
+import { createCustomerAttribute } from './createCustomerAttribute';
+import { deleteClientAndConfiguration } from './deleteClientAndConfiguration';
+import { getClient } from './getClient';
+import { getClientConfiguration } from './getClientConfiguration';
+import { getClients } from './getClients';
+import { getCustomerAttribute } from './getCustomerAttribute';
+import { updateClient } from './updateClient';
+import { updateClientConfiguration } from './updateClientConfiguration';
+import { updateCustomerAttribute } from './updateCustomerAttribute';
+export class ClientsRepository extends BaseRepository {
+    /**
+     * Get a client with filters. If multiple clients are found, the first one is returned.
+     * @param  {GetClientParams} params containing information to get a client
+     * - filters.clientId: The client id, optional
+     * - filters.email: The email, optional
+     */
+    async getClient(params) {
+        this.logger.trace(params, 'ClientsRepository::getClient started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getClient(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'ClientsRepository::getClient result');
+        return result;
+    }
+    /**
+     * Get clients with filters. If multiple clients are found, all are returned.
+     * @param  {GetClientsParams} params containing information to get clients
+     * - filters.email: The email filter
+     */
+    async getClients(params) {
+        this.logger.trace(params, 'ClientsRepository::getClients started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getClients(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'ClientsRepository::getClients result');
+        return result;
+    }
+    /**
+     * Create client
+     * @param  {CreateClientParams} params containing information to create a client
+     * - name: client name
+     * - email: client email
+     * - uuid: client uuid
+     * - clientTypeId: client type id, optional
+     * - dataSourceTypeId: data source type id, optional
+     * - sievaUserName: sieva user name, optional
+     * - sievaBatchId: sieva batch id, optional
+     * - salesforceId: salesforce id, optional
+     * - accumaticaId: accumatica id, optional
+     * - expirationDate: expiration date, optional
+     * - useType: use type, optional
+     * - btCustomerId: bt customer id, optional
+     * - activationCampaign: activation campaign, optional
+     * - organizationId: organization id, optional
+     *  @returns {Promise<Client>} The created client
+     */
+    async createClient(params) {
+        this.logger.trace(params, 'ClientsRepository::createClient started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createClient(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'ClientsRepository::createClient result');
+        return result;
+    }
+    /**
+     * Create client
+     * @param  {UpdateClientParams} params containing information to update a client
+     * - filters.clientId: The id of the client to update
+     * - values.name: client name, optional
+     * - values.email: client email, optional
+     * - values.uuid: client uuid, optional
+     * - values.clientTypeId: client type id, optional
+     * - values.dataSourceTypeId: data source type id, optional
+     * - values.sievaUserName: sieva user name, optional
+     * - values.sievaBatchId: sieva batch id, optional
+     * - values.salesforceId: salesforce id, optional
+     * - values.accumaticaId: accumatica id, optional
+     * - values.expirationDate: expiration date, optional
+     * - values.useType: use type, optional
+     * - values.btCustomerId: bt customer id, optional
+     * - values.activationCampaign: activation campaign, optional
+     * - values.organizationId: organization id, optional
+     *  @returns {Promise<boolean>} True if the client was updated, false otherwise
+     */
+    async updateClient(params) {
+        this.logger.trace(params, 'ClientsRepository::updateClient started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateClient(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'ClientsRepository::updateClient result');
+        return result;
+    }
+    /**
+     * Delete a client and its configurations
+     * @param  {DeleteClientParams} params containing information to delete a client
+     * - filters.clientId: The id of the client to delete
+     * @returns {Promise<boolean>} True if the client was deleted, false otherwise
+     */
+    async deleteClientAndConfigurations(params) {
+        this.logger.trace(params, 'ClientsRepository::deleteClientAndConfigurations started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await deleteClientAndConfiguration(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'ClientsRepository::deleteClientAndConfigurations result');
+        return result;
+    }
+    /**
+     * Get a client configuration
+     * @param  {GetClientConfigurationParams} params containing information to get a client configuration
+     * - filters.clientId: The client id
+     */
+    async getClientConfiguration(params) {
+        this.logger.trace(params, 'ClientsRepository::getClientConfiguration started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getClientConfiguration(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'ClientsRepository::getClientConfiguration result');
+        return result;
+    }
+    /**
+     * Create a client configuration
+     * @param  {CreateClientConfigurationParams} params containing information to create a client configuration
+     * - clientId: The client id
+     * - movementTripThreshold: The movement trip threshold
+     * - stopTripThreshold: The stop trip threshold
+     * - mapUpdateMode: The map update mode
+     * - maxUsersAllowed: The max users allowed
+     */
+    async createClientConfiguration(params) {
+        this.logger.trace(params, 'ClientsRepository::createClientConfiguration started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createClientConfiguration(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'ClientsRepository::createClientConfiguration result');
+        return result;
+    }
+    /**
+     * Update a client configuration
+     * @param  {UpdateClientConfigurationParams} params containing information to update a client configuration
+     * - filters.clientId: The client id
+     * - values.movementTripThreshold: The movement trip threshold, optional
+     * - values.stopTripThreshold: The stop trip threshold, optional
+     * - values.mapUpdateMode: The map update mode, optional
+     * - values.maxUsersAllowed: The max users allowed, optional
+     * @returns {Promise<boolean>} True if the client configuration was updated, false otherwise
+     */
+    async updateClientConfiguration(params) {
+        this.logger.trace(params, 'ClientsRepository::updateClientConfiguration started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateClientConfiguration(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'ClientsRepository::updateClientConfiguration result');
+        return result;
+    }
+    /**
+     * Create a customer attribute for a client
+     * @param  {CreateCustomerAttributeParams} params containing information to create a customer attribute
+     * - clientId: The client id
+     * - enterprise: The enterprise, optional
+     * - maintenanceModule: The maintenance module, optional
+     */
+    async createCustomerAttribute(params) {
+        this.logger.trace(params, 'ClientsRepository::createCustomerAttribute started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await createCustomerAttribute(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'ClientsRepository::createCustomerAttribute result');
+        return result;
+    }
+    /**
+     * Update a customer attribute for a client
+     * @param  {UpdateCustomerAttributeParams} params containing information to update a customer attribute
+     * - filters.clientId: The client id
+     * - enterprise: The enterprise, optional
+     * - maintenanceModule: The maintenance module, optional
+     * @returns {Promise<boolean>} True if the customer attribute was updated, false otherwise
+     */
+    async updateCustomerAttribute(params) {
+        this.logger.trace(params, 'ClientsRepository::updateCustomerAttribute started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await updateCustomerAttribute(novaDataSource, params, this.logger);
+        this.logger.trace({ result }, 'ClientsRepository::updateCustomerAttribute result');
+        return result;
+    }
+    /**
+     * Get a costumer attribute for a client
+     * @param  {GetCustomerAttributeParams} params containing information to get a customer attribute
+     * - filters.clientId: The client id
+     */
+    async getCustomerAttribute(params) {
+        this.logger.trace(params, 'ClientsRepository::getCustomerAttribute started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getCustomerAttribute(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'ClientsRepository::getCustomerAttribute result');
+        return result;
+    }
+}

package/dist/repositories/clients/updateClient.js

@@ -0,0 +1,52 @@
+import { Client } from '../../entities';
+import { uuidStringToBinaryBuffer } from '../../utils/uuidHelpers';
+export const updateClient = async (novaDataSource, params, logger) => {
+    // clientId is required
+    if (!params?.filters?.clientId) {
+        logger.warn({ params }, 'ClientsRepository::updateClient - missing required parameters');
+        return false;
+    }
+    // at least one field to update is required
+    if (!params?.values?.name &&
+        !params?.values?.uuid &&
+        !params?.values?.email &&
+        !params?.values?.clientTypeId &&
+        !params?.values?.dataSourceTypeId &&
+        !params?.values?.sievaUserName &&
+        !params?.values?.sievaBatchId &&
+        !params?.values?.salesforceId &&
+        !params?.values?.accumaticaId &&
+        !params?.values?.expirationDate &&
+        !params?.values?.useType &&
+        !params?.values?.btCustomerId &&
+        !params?.values?.activationCampaign &&
+        !params?.values?.organizationId) {
+        logger.warn({ params }, 'ClientsRepository::updateClient - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientsRepository = dataSource.getRepository(Client);
+        const now = new Date();
+        const result = await clientsRepository
+            .createQueryBuilder()
+            .update(Client)
+            .set({
+            name: params.values.name,
+            uuid: params.values.uuid ? uuidStringToBinaryBuffer(params.values.uuid) : undefined,
+            email: params.values.email,
+            clientTypeId: params.values.clientTypeId,
+            dataSourceTypeId: params.values.dataSourceTypeId,
+            salesforceId: params.values.salesforceId,
+            accumaticaId: params.values.accumaticaId,
+            expirationDate: params.values.expirationDate,
+            useType: params.values.useType,
+            btCustomerId: params.values.btCustomerId,
+            activationCampaign: params.values.activationCampaign,
+            organizationId: params.values.organizationId,
+            modifiedAt: now,
+        })
+            .where('id = :id', { id: params.filters.clientId })
+            .execute();
+        return result.affected > 0;
+    }, 'ClientsRepository::updateClient');
+};

package/dist/repositories/clients/updateClientConfiguration.js

@@ -0,0 +1,31 @@
+import { ClientConfiguration } from '../../entities';
+export const updateClientConfiguration = async (novaDataSource, params, logger) => {
+    // clientId is required
+    if (!params?.filters?.clientId) {
+        logger.warn({ params }, 'ClientsRepository::updateClientConfiguration - missing required parameters');
+        return false;
+    }
+    // at least one field to update is required
+    if (!params?.values?.movementTripThreshold &&
+        !params?.values?.stopTripThreshold &&
+        !params?.values?.mapUpdateMode &&
+        !params?.values?.maxUsersAllowed) {
+        logger.warn({ params }, 'ClientsRepository::updateClientConfiguration - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientConfigurationRepository = dataSource.getRepository(ClientConfiguration);
+        const result = await clientConfigurationRepository
+            .createQueryBuilder()
+            .update(ClientConfiguration)
+            .set({
+            movementTripThreshold: params.values.movementTripThreshold,
+            stopTripThreshold: params.values.stopTripThreshold,
+            mapUpdateMode: params.values.mapUpdateMode,
+            maxUsersAllowed: params.values.maxUsersAllowed,
+        })
+            .where('clientId = :clientId', { clientId: params.filters.clientId })
+            .execute();
+        return result.affected > 0;
+    }, 'ClientsRepository::updateClientConfiguration');
+};

package/dist/repositories/clients/updateCustomerAttribute.js

@@ -0,0 +1,27 @@
+import { ClientConfiguration } from '../../entities';
+import { CustomerAttribute } from '../../entities/customerAttribute';
+export const updateCustomerAttribute = async (novaDataSource, params, logger) => {
+    // clientId is required
+    if (!params?.filters?.clientId) {
+        logger.warn({ params }, 'ClientsRepository::updateClientConfiguration - missing required parameters');
+        return false;
+    }
+    // at least one field to update is required
+    if (params?.values?.enterprise == null && params?.values?.maintenanceModule == null) {
+        logger.warn({ params }, 'ClientsRepository::updateClientConfiguration - missing required parameters');
+        return false;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const clientConfigurationRepository = dataSource.getRepository(ClientConfiguration);
+        const result = await clientConfigurationRepository
+            .createQueryBuilder()
+            .update(CustomerAttribute)
+            .set({
+            enterprise: params.values.enterprise,
+            maintenanceModule: params.values.maintenanceModule,
+        })
+            .where('clientId = :clientId', { clientId: params.filters.clientId })
+            .execute();
+        return result.affected > 0;
+    }, 'ClientsRepository::updateCustomerAttribute');
+};

package/dist/repositories/countries/getCountries.js

@@ -0,0 +1,14 @@
+import { Country } from '../../entities';
+export const getCountries = async (novaDataSource, params) => {
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const countriesRepository = dataSource.getRepository(Country);
+        let queryBuilder = countriesRepository.createQueryBuilder('country');
+        if (params?.filters?.idList?.length) {
+            queryBuilder = queryBuilder.where('country.id IN (:...idList)', {
+                idList: params.filters.idList,
+            });
+        }
+        const result = await queryBuilder.getMany();
+        return result;
+    }, 'CountriesRepository::getCountries');
+};

package/dist/repositories/countries/getCountry.js

@@ -0,0 +1,23 @@
+import { Country } from '../../entities';
+export const getCountry = async (novaDataSource, params, logger) => {
+    if (!params?.filters?.id && !params?.filters?.alpha2Code) {
+        logger.warn({ params }, 'CountriesRepository::getCountry - missing required parameters');
+        return null;
+    }
+    return novaDataSource.safeQuery(async (dataSource) => {
+        const countriesRepository = dataSource.getRepository(Country);
+        let queryBuilder = countriesRepository.createQueryBuilder('country');
+        if (params.filters.id) {
+            queryBuilder = queryBuilder.where('country.id = :id', {
+                id: params.filters.id,
+            });
+        }
+        if (params.filters.alpha2Code) {
+            queryBuilder = queryBuilder.where('country.alpha2Code = :alpha2Code', {
+                alpha2Code: params.filters.alpha2Code,
+            });
+        }
+        const result = await queryBuilder.getOne();
+        return result;
+    }, 'CountriesRepository::getCountry');
+};

package/dist/repositories/countries/index.js

@@ -0,0 +1,33 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { BaseRepository } from '../baseRepository';
+import { getCountries } from './getCountries';
+import { getCountry } from './getCountry';
+export class CountriesRepository extends BaseRepository {
+    /**
+     * Get country
+     * @param {GetCountryParams} params containing information to get a country
+     * - filters.id: The country id
+     * - filters.alpha2Code: The country alpha2Code
+     * @returns The country information
+     */
+    async getCountry(params) {
+        this.logger.trace(params, 'CountriesRepository::getCountry started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getCountry(novaDataSource, params, this.logger);
+        this.logger.trace(result, 'CountriesRepository::getCountry result');
+        return result;
+    }
+    /**
+     * Get countries
+     * @param {GetCountriesParams} params containing information to get countries
+     * - filters.idList: The country id list. If not provided, all countries will be returned
+     * @returns The countries information
+     */
+    async getCountries(params) {
+        this.logger.trace(params, 'CountriesRepository::getCountries started with params');
+        const novaDataSource = new NovaDataSource(this.novaDataSourceConfig, this.logger);
+        const result = await getCountries(novaDataSource, params);
+        this.logger.trace(result, 'CountriesRepository::getCountries result');
+        return result;
+    }
+}