@spytecgps/nova-orm 0.0.25 → 0.0.26

package/dist/repositories/devices/createClientDeviceSetting.d.ts

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

package/dist/repositories/devices/createDevice.d.ts

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

package/dist/repositories/devices/deleteDevice.d.ts

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

package/dist/repositories/devices/generateDeviceIdentifierKey.d.ts

@@ -0,0 +1,4 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { GenerateIdentifierKeyParams } from '../../types/devices';
+import { Logger } from '../../types/logger';
+export declare const generateDeviceIdentifierKey: (novaDataSource: NovaDataSource, params: GenerateIdentifierKeyParams, logger: Logger) => Promise<string>;

package/dist/repositories/devices/getClientDeviceSetting.d.ts

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

package/dist/repositories/devices/getClientDeviceSettings.d.ts

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

package/dist/repositories/devices/getDevice.d.ts

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

package/dist/repositories/devices/getDevices.d.ts

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

package/dist/repositories/devices/getFilteredImeisWithStatus.d.ts

@@ -0,0 +1,4 @@
+import { NovaDataSource } from '../../novaDataSource';
+import { GetFilteredImeisWithStatusParams } from '../../types/devices';
+import { Logger } from '../../types/logger';
+export declare const getFilteredImeisWithStatus: (novaDataSource: NovaDataSource, params: GetFilteredImeisWithStatusParams, logger: Logger) => Promise<string[]>;

package/dist/repositories/devices/getImeiIccidCarrier.d.ts

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

package/dist/repositories/devices/getImeiIccidCarriers.d.ts

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

package/dist/repositories/devices/index.d.ts

@@ -1,28 +1,178 @@
-import { Device, DeviceType } from '../../entities';
-import { GetDeviceByImeiParams, GetDevicesByDeviceTypeIdParams, GetDeviceTypesParams } from '../../types/devices';
+import { ClientDeviceSetting, Device, DeviceType, ImeiIccidCarrier } from '../../entities';
+import { CreateClientDeviceSettingParams, CreateDeviceParams, DeleteDeviceParams, GenerateIdentifierKeyParams, GetClientDeviceSettingParams, GetClientDeviceSettingsParams, GetDeviceParams, GetDevicesParams, GetDeviceTypesParams, GetFilteredImeisWithStatusParams, GetImeiIccidCarrierParams, GetImeiIccidCarriersParams, UpdateClientDeviceSettingParams, UpdateDeviceParams, UpdateImeiIccidCarrierParams } from '../../types/devices';
 import { BaseRepository } from './../baseRepository';
 export declare class DevicesRepository extends BaseRepository {
     /**
-     * Get device by imei
-     * @param  {GetDeviceByImeiParams} params containing information to get a device by imei
+     * Get device with filters
+     * @param  {GetDeviceParams} params containing information to get a device with filters
      * - filters.imei: The imei of the device
+     * - filters.id: The id of the device
      * - projectionOptions.withDeviceType: Whether to get the device type object
      * - projectionOptions.withIccidCarrier: Whether to get the iccid carrier object
      */
-    getDeviceByImei(params: GetDeviceByImeiParams): Promise<Device>;
+    getDevice(params: GetDeviceParams): Promise<Device>;
     /**
      * Get devices by type id
-     * @param  {GetDevicesByDeviceTypeIdParams} params containing information to get devices by type id
+     * @param  {GetDevicesParams} params containing information to get devices by type id
      * - filters.deviceTypeId: The device type id
-     * - filters.onlyActiveDevices: Whether to get only active devices
+     * - filters.status: The device status
+     * - filters.clientId: The client id
+     * - filters.imeiList: The imei list
      * - projectionOptions.withDeviceType: Whether to get the device type object
      * - projectionOptions.withIccidCarrier: Whether to get the iccid carrier object
      */
-    getDevicesByDeviceTypeId(params: GetDevicesByDeviceTypeIdParams): Promise<Device[]>;
+    getDevices(params: GetDevicesParams): Promise<Device[]>;
+    /**
+     * Get filtered imeis with status
+     * @param  {GetFilteredImeisWithStatusParams} params containing information to get filtered imeis with status
+     * - filters.imeiList: The imei list to filter
+     * - filters.status: The device status
+     * @returns {Promise<string>} The imei list filtered by status
+     */
+    getFilteredImeisWithStatus(params: GetFilteredImeisWithStatusParams): Promise<string[]>;
+    /**
+     * Create device
+     * @param  {CreateDeviceParams} params containing information to create a device
+     * - identifier: The device identifier
+     * - imei: The imei of the device
+     * - clientId: The client id
+     * - deviceTypeId: The device type id
+     * - iccid: The iccid of the device
+     * - name: The name of the device
+     * - color: The color of the device
+     * - icon: The icon of the device
+     * - status: The status of the device
+     * - forward: Whether to forward the device
+     * - description: The description of the device
+     * - dataSourceTypeId: The data source type id of the device
+     * - assetCategoryId: The asset category id of the device
+     * - usageRegion: The usage region of the device
+     * - createdBy: The user who created the device
+     *
+     * @returns {Promise<Device>} The created device
+     */
+    createDevice(params: CreateDeviceParams): Promise<Device>;
+    /**
+     * Update device
+     * @param  {UpdateDeviceParams} params containing information to update a device
+     * - filters.imei: The imei of the device
+     * - filters.status: The status of the device
+     * - values.clientId: The client id
+     * - values.deviceTypeId: The device type id
+     * - values.iccid: The iccid of the device
+     * - values.name: The name of the device
+     * - values.color: The color of the device
+     * - values.icon: The icon of the device
+     * - values.status: The status of the device
+     * - values.forward: Whether to forward the device
+     * - values.description: The description of the device
+     * - values.dataSourceTypeId: The data source type id of the device
+     * - values.assetCategoryId: The asset category id of the device
+     * - values.usageRegion: The usage region of the device
+     * - values.modifiedBy: The user who updated the device
+     * @returns {Promise<boolean>} Whether the device was updated
+     */
+    updateDevice(params: UpdateDeviceParams): Promise<boolean>;
+    /**
+     * Delete device
+     * @param  {DeleteDeviceParams} params containing information to delete a device
+     * - filters.imei: The imei of the device
+     *
+     * @returns {Promise<boolean>} Whether the device was deleted
+     */
+    deleteDevice(params: DeleteDeviceParams): Promise<boolean>;
+    /**
+     * Generate device identifier key from device type and device identifier
+     * @param  {GenerateIdentifierKeyParams} params containing information to generate a device identifier key
+     * - deviceTypeId: The device type id
+     * - deviceIdentifier: The device identifier
+     * @returns {Promise<string>} The generated device identifier key
+     */
+    generateDeviceIdentifierKey(params: GenerateIdentifierKeyParams): Promise<string>;
     /**
      * Get device types
      * @param  {GetDeviceTypesParams} params containing information to get device types
      * - filters.onlyWithRelatedIccidCarrier: Whether to get only device types with iccid carrier
      */
     getDeviceTypes(params: GetDeviceTypesParams): Promise<DeviceType[]>;
+    /**
+     * Get ImeiIccidCarrier
+     * @param  {GetImeiIccidCarrierParams} params containing information to get the ImeiIccidCarrier
+     * - filters.imei: The imei of the device
+     * - filters.iccid: The iccid of the device
+     * @returns {Promise<ImeiIccidCarrier>} The imei iccid carrier
+     */
+    getImeiIccidCarrier(params: GetImeiIccidCarrierParams): Promise<ImeiIccidCarrier>;
+    /**
+     * Get ImeiIccidCarriers from a list of imeis
+     * @param  {GetImeiIccidCarriersParams} params containing information to get the ImeiIccidCarriers
+     * - filters.imeis: The imeis of the devices
+     * @returns {Promise<ImeiIccidCarrier[]>} The imei iccid carriers
+     */
+    getImeiIccidCarriers(params: GetImeiIccidCarriersParams): Promise<ImeiIccidCarrier[]>;
+    /**
+     * Update the ImeiIccidCarrier
+     * @param  {UpdateImeiIccidCarrierParams} params containing information to update the ImeiIccidCarrier
+     * - filters.imei: The imei of the device to update
+     * - filters.iccid: The iccid of the device to update
+     * - values.carrierId: The carrier id
+     * - values.phone: The phone or MSISDN of the device
+     * - values.deviceTypeId: The device type id
+     * - values.serviceProviderProductId: The service provider product id
+     * - values.isValid: Whether the imei iccid carrier is valid
+     * - values.realModel: The real model of the device
+     * - values.po: The purchase order number of the device
+     * - values.outOfInventory: Whether the device is out of inventory
+     * - values.apn: The apn of the device
+     *
+     * @returns {Promise<boolean>} Whether the imei iccid carrier was updated
+     */
+    updateImeiIccidCarrier(params: UpdateImeiIccidCarrierParams): Promise<boolean>;
+    /**
+     * Get a ClientDeviceSetting
+     * @param  {GetClientDeviceSettingParams} params containing information to get a ClientDeviceSetting
+     * - filters.imei: The imei of the device
+     * - filters.clientId: The client id
+     * @returns {Promise<ClientDeviceSetting>} The ClientDeviceSetting
+     */
+    getClientDeviceSetting(params: GetClientDeviceSettingParams): Promise<ClientDeviceSetting>;
+    /**
+     * Get a list of ClientDeviceSettings with filters
+     * @param  {GetClientDeviceSettingsParams} params containing information to get ClientDeviceSettings
+     * - filters.clientId: The client id
+     * @returns {Promise<ClientDeviceSetting[]>} An array of ClientDeviceSettings matching the filters
+     */
+    getClientDeviceSettings(params: GetClientDeviceSettingsParams): Promise<ClientDeviceSetting[]>;
+    /**
+     * Create a ClientDeviceSetting
+     * @param  {CreateClientDeviceSettingParams} params containing information to create a ClientDeviceSetting
+     * - values.imei: The imei of the device
+     * - values.clientId: The client id
+     * - values.generateTrips: Whether to generate trips
+     * - values.movingPingFrequency: The moving ping frequency
+     * - values.stoppedPingFrequency: The stopped ping frequency
+     * - values.fixedStatus: The fixed status
+     * - values.stopThresholdMinutes: The threshold in minutes to consider that the device is stopped
+     * - values.offlineThresholdMinutes: The threshold in minutes to consider that the device is offline
+     * - values.movementThresholdSpeed: The threshold for the speed to consider that the device is moving
+     * - values.externalBatteryInformation: The external battery information
+     * @returns {Promise<ClientDeviceSetting>} The created ClientDeviceSetting
+     */
+    createClientDeviceSetting(params: CreateClientDeviceSettingParams): Promise<ClientDeviceSetting>;
+    /**
+     * Update a ClientDeviceSetting
+     * @param  {UpdateClientDeviceSettingParams} params containing information to update a ClientDeviceSetting
+     * - filters.imei: The imei of the device
+     * - filters.clientId: The client id
+     * - values.generateTrips: Whether to generate trips
+     * - values.movingPingFrequency: The moving ping frequency
+     * - values.stoppedPingFrequency: The stopped ping frequency
+     * - values.fixedStatus: The fixed status
+     * - values.stopThresholdMinutes: The threshold in minutes to consider that the device is stopped
+     * - values.offlineThresholdMinutes: The threshold in minutes to consider that the device is offline
+     * - values.movementThresholdSpeed: The threshold for the speed to consider that the device is moving
+     * - values.externalBatteryInformation: The external battery information
+     * @returns {Promise<boolean>} Whether the ClientDeviceSetting was updated
+     */
+    updateClientDeviceSetting(params: UpdateClientDeviceSettingParams): Promise<boolean>;
 }

package/dist/repositories/devices/updateClientDeviceSetting.d.ts

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

package/dist/repositories/devices/updateDevice.d.ts

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

package/dist/repositories/devices/updateImeiIccidCarrier.d.ts

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

package/dist/types/devices.d.ts

@@ -1,24 +1,156 @@
-export interface GetDeviceByImeiParams {
+import { DeviceStatus } from './enums';
+export interface GetDeviceParams {
     filters: {
-        imei: string;
+        id?: number;
+        imei?: string;
     };
     projectionOptions: {
         withDeviceType: boolean;
         withIccidCarrier: boolean;
+        withClientDeviceSettings: boolean;
     };
 }
-export interface GetDevicesByDeviceTypeIdParams {
+export interface GetDevicesParams {
     filters: {
-        deviceTypeId: number;
-        onlyActiveDevices: boolean;
+        deviceTypeId?: number;
+        status?: DeviceStatus;
+        clientId?: number;
+        imeiList?: string[];
     };
     projectionOptions: {
         withDeviceType: boolean;
         withIccidCarrier: boolean;
+        withClientDeviceSettings: boolean;
+    };
+}
+export interface GetFilteredImeisWithStatusParams {
+    filters: {
+        imeiList: string[];
+        status: DeviceStatus;
     };
 }
+export interface CreateDeviceParams {
+    values: {
+        imei: string;
+        clientId: number;
+        deviceTypeId: number;
+        identifier?: string;
+        iccid?: string;
+        name?: string;
+        color?: string;
+        icon?: string;
+        status?: string;
+        forward?: boolean;
+        description?: string;
+        dataSourceTypeId?: number;
+        assetCategoryId?: number;
+        usageRegion?: string;
+        createdBy?: string;
+    };
+    updateParamsIfDeviceExists?: UpdateDeviceParams;
+}
+export interface UpdateDeviceParams {
+    filters: {
+        imei: string;
+        status?: DeviceStatus;
+    };
+    values: {
+        clientId?: number;
+        deviceTypeId?: number;
+        iccid?: string;
+        name?: string;
+        color?: string;
+        icon?: string;
+        status?: DeviceStatus;
+        forward?: boolean;
+        description?: string;
+        dataSourceTypeId?: number;
+        assetCategoryId?: number;
+        usageRegion?: string;
+        modifiedBy?: string;
+    };
+}
+export interface DeleteDeviceParams {
+    filters: {
+        imei: string;
+    };
+}
+export interface GenerateIdentifierKeyParams {
+    deviceTypeId: number;
+    deviceIdentifier: string;
+}
 export interface GetDeviceTypesParams {
     filters: {
-        onlyWithRelatedIccidCarrier: boolean;
+        deviceTypeIdList?: number[];
+        brand?: string;
+        model?: string;
+        onlyWithRelatedIccidCarrier?: boolean;
+    };
+}
+export interface GetImeiIccidCarrierParams {
+    filters: {
+        imei?: string;
+        iccid?: string;
+    };
+}
+export interface GetImeiIccidCarriersParams {
+    filters: {
+        imeiList: string[];
+    };
+}
+export interface UpdateImeiIccidCarrierParams {
+    filters: {
+        imei?: string;
+        iccid?: string;
+    };
+    values: {
+        carrier?: number;
+        phone?: string;
+        deviceTypeId?: number;
+        serviceProviderProductId?: number;
+        isValid?: boolean;
+        realModel?: string;
+        po?: string;
+        outOfInventory?: boolean;
+        apn?: string;
+    };
+}
+export interface GetClientDeviceSettingParams {
+    filters: {
+        imei: string;
+        clientId: number;
+    };
+}
+export interface GetClientDeviceSettingsParams {
+    filters: {
+        clientId: number;
+    };
+}
+export interface CreateClientDeviceSettingParams {
+    imei: string;
+    clientId: number;
+    generateTrips?: boolean;
+    movingPingFrequency?: number;
+    stoppedPingFrequency?: number;
+    fixedStatus?: string;
+    stopThresholdMinutes?: number;
+    offlineThresholdMinutes?: number;
+    movementThresholdSpeed?: number;
+    externalBatteryInformation?: boolean;
+}
+export interface UpdateClientDeviceSettingParams {
+    filters: {
+        imei: string;
+        clientId: number;
+    };
+    values: {
+        generateTrips?: boolean;
+        movingPingFrequency?: number;
+        stoppedPingFrequency?: number;
+        fixedStatus?: string;
+        stopThresholdMinutes?: number;
+        offlineThresholdMinutes?: number;
+        movementThresholdSpeed?: number;
+        externalBatteryInformation?: boolean;
     };
 }

package/dist/utils/boolToNumberTransformer.d.ts

@@ -0,0 +1,5 @@
+import { ValueTransformer } from 'typeorm';
+export declare class BoolToNumberTransformer implements ValueTransformer {
+    to(value: boolean | null): number | null;
+    from(value: number): boolean | null;
+}

package/dist/utils/consoleLogger.d.ts

@@ -0,0 +1,10 @@
+import { Logger, LogLevel } from '../types/logger';
+export declare class ConsoleLogger implements Logger {
+    fatal: (msgOrObj: string | object, msg?: string, ...args: any[]) => void;
+    error: (msgOrObj: string | object, msg?: string, ...args: any[]) => void;
+    warn: (msgOrObj: string | object, msg?: string, ...args: any[]) => void;
+    info: (msgOrObj: string | object, msg?: string, ...args: any[]) => void;
+    debug: (msgOrObj: string | object, msg?: string, ...args: any[]) => void;
+    trace: (msgOrObj: string | object, msg?: string, ...args: any[]) => void;
+    log: (level: LogLevel, msgOrObj: string | object, msg?: string, ...args: any[]) => void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spytecgps/nova-orm",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "ORM with PlanetScale",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/repositories/devices/getDeviceByImei.d.ts

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

package/dist/repositories/devices/getDevicesByDeviceTypeId.d.ts

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

package/dist/utils/writeToLog.d.ts

@@ -1,2 +0,0 @@
-import { Logger, LogLevel } from '../types/logger';
-export declare const writeToLog: (logger: Logger, level: LogLevel, obj: any, message: string) => void;