kuzzle-device-manager 0.4.13 → 2.0.0-rc3

package/lib/core-classes/Decoder.d.ts

@@ -1,6 +1,6 @@
 import { JSONObject, KuzzleRequest, HttpRoute } from 'kuzzle';
-import { Device, BaseAsset } from '../models';
-import { AssetMeasures, DeviceContent } from '../types';
+import { DecodedPayload } from '../types/DecodedPayload';
+import { DecoderContent } from '../types';
 /**
  * Base class to implement a decoder for a device model.
  * The device model must be passed to the parent constructor.
@@ -12,6 +12,10 @@ export declare abstract class Decoder {
      * Device model name
      */
     deviceModel: string;
+    /**
+     * Array of device measure type
+     */
+    deviceMeasures: string[];
     /**
      * Custom name for the associated API action in the "payload" controller
      */
@@ -40,8 +44,12 @@ export declare abstract class Decoder {
     get http(): HttpRoute[];
     /**
      * @param deviceModel Device model for this decoder
+     * @param deviceMeasures Devices measure types for this decoder
+     *
+     * @example
+     * super('AbeewayGPS', ['position']);
      */
-    constructor(deviceModel: string);
+    constructor(deviceModel: string, deviceMeasures: string[]);
     /**
      * Validate the payload format before processing.
      *
@@ -60,67 +68,13 @@ export declare abstract class Decoder {
      * Decode the payload:
      *  - set "reference"
      *  - fetch measures
-     *  - fetch qos
      *
      * @param payload Raw payload received in the API action body
      * @param request Original request
      *
-     * @returns Device content to save
-     */
-    abstract decode(payload: JSONObject, request: KuzzleRequest): Promise<DeviceContent>;
-    /**
-     * Hook executed before processing the payload but after validation
-     *
-     * @param payload Raw payload received in the API action body
-     * @param request Original request
-     */
-    beforeProcessing(payload: JSONObject, request: KuzzleRequest): Promise<void>;
-    /**
-     * Enrichment hook executed before registering a device
-     *
-     * @param device Densor before being persisted
-     * @param request Original request
-     *
-     * @returns Enriched device
-     */
-    beforeRegister(device: Device, request: KuzzleRequest): Promise<Device>;
-    /**
-     * Hook executed after registering a device.
-     * Return value of this method will be returned in the API action result.
-     *
-     * @param device Device after being persisted
-     * @param request Original request
-     *
-     * @returns Result of the corresponding API action
-     */
-    afterRegister(device: Device, request: KuzzleRequest): Promise<any>;
-    /**
-    * Enrichment hook executed before updating a device
-    *
-    * @param device Device before being updated
-    * @param request Original request
-    *
-    * @returns Enriched device
-    */
-    beforeUpdate(device: Device, request: KuzzleRequest): Promise<Device>;
-    /**
-     * Hook executed after updating a device.
-     * Return value of this method will be returned in the API action result.
-     *
-     * @param device Device after being updated
-     * @param request Original request
-     *
-     * @returns Result of the corresponding API action
-     */
-    afterUpdate(device: Device, asset: BaseAsset, request: KuzzleRequest): Promise<any>;
-    /**
-     * Build the "measures" property that will be persisted in the asset document
-     *
-     * @param device Device after being updated
-     *
-     * @returns Content of the "measures" property
+     * @returns Measure
      */
-    copyToAsset(device: Device): Promise<AssetMeasures>;
+    abstract decode(payload: JSONObject, request: KuzzleRequest): Promise<DecodedPayload>;
     /**
      * Checks if the provided properties are present in the payload
      *
@@ -130,4 +84,5 @@ export declare abstract class Decoder {
      * @throws
      */
     ensureProperties(payload: JSONObject, paths: string[]): void | never;
+    serialize(): DecoderContent;
 }

package/lib/core-classes/Decoder.js

@@ -7,7 +7,6 @@ exports.Decoder = void 0;
 const kuzzle_1 = require("kuzzle");
 const lodash_1 = __importDefault(require("lodash"));
 /* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-empty-function */
 /**
  * Base class to implement a decoder for a device model.
  * The device model must be passed to the parent constructor.
@@ -16,8 +15,12 @@ const lodash_1 = __importDefault(require("lodash"));
 class Decoder {
     /**
      * @param deviceModel Device model for this decoder
+     * @param deviceMeasures Devices measure types for this decoder
+     *
+     * @example
+     * super('AbeewayGPS', ['position']);
      */
-    constructor(deviceModel) {
+    constructor(deviceModel, deviceMeasures) {
         /**
          * Custom mappings for the payload collection.
          * It will be injected in the "payload" property and it should allows to index
@@ -34,6 +37,7 @@ class Decoder {
          */
         this.payloadsMappings = {};
         this.deviceModel = deviceModel;
+        this.deviceMeasures = deviceMeasures;
     }
     /**
      * Define custom HTTP routes
@@ -44,7 +48,10 @@ class Decoder {
         this._http = http;
     }
     get http() {
-        return this._http || [{ verb: 'post', path: `device-manager/payload/${this.action}` }];
+        if (!this._http) {
+            this._http = [{ path: `device-manager/payload/${this.action}`, verb: 'post' }];
+        }
+        return this._http;
     }
     /**
      * Validate the payload format before processing.
@@ -62,88 +69,6 @@ class Decoder {
     async validate(payload, request) {
         return true;
     }
-    /**
-     * Hook executed before processing the payload but after validation
-     *
-     * @param payload Raw payload received in the API action body
-     * @param request Original request
-     */
-    async beforeProcessing(payload, request) {
-    }
-    /**
-     * Enrichment hook executed before registering a device
-     *
-     * @param device Densor before being persisted
-     * @param request Original request
-     *
-     * @returns Enriched device
-     */
-    async beforeRegister(device, request) {
-        return device;
-    }
-    /**
-     * Hook executed after registering a device.
-     * Return value of this method will be returned in the API action result.
-     *
-     * @param device Device after being persisted
-     * @param request Original request
-     *
-     * @returns Result of the corresponding API action
-     */
-    async afterRegister(device, request) {
-        return {
-            tenantId: device._source.tenantId,
-            device: device.serialize(),
-            asset: null,
-        };
-    }
-    /**
-    * Enrichment hook executed before updating a device
-    *
-    * @param device Device before being updated
-    * @param request Original request
-    *
-    * @returns Enriched device
-    */
-    async beforeUpdate(device, request) {
-        return device;
-    }
-    /**
-     * Hook executed after updating a device.
-     * Return value of this method will be returned in the API action result.
-     *
-     * @param device Device after being updated
-     * @param request Original request
-     *
-     * @returns Result of the corresponding API action
-     */
-    async afterUpdate(device, asset, request) {
-        return {
-            tenantId: device._source.tenantId,
-            device: device.serialize(),
-            asset: asset ? asset.serialize() : null,
-        };
-    }
-    /**
-     * Build the "measures" property that will be persisted in the asset document
-     *
-     * @param device Device after being updated
-     *
-     * @returns Content of the "measures" property
-     */
-    async copyToAsset(device) {
-        const measures = {};
-        for (const [measureType, measure] of Object.entries(device._source.measures)) {
-            measures[measureType] = {
-                id: device._id,
-                model: device._source.model,
-                reference: device._source.reference,
-                ...measure,
-                qos: device._source.qos,
-            };
-        }
-        return measures;
-    }
     /**
      * Checks if the provided properties are present in the payload
      *
@@ -159,8 +84,13 @@ class Decoder {
             }
         }
     }
+    serialize() {
+        return {
+            deviceMeasures: this.deviceMeasures,
+            deviceModel: this.deviceModel
+        };
+    }
 }
 exports.Decoder = Decoder;
 /* eslint-enable @typescript-eslint/no-unused-vars */
-/* eslint-enable @typescript-eslint/no-empty-function */
 //# sourceMappingURL=Decoder.js.map

package/lib/core-classes/DeviceManagerEngine.d.ts

@@ -1,13 +1,16 @@
 import { Plugin } from 'kuzzle';
-import { AbstractEngine } from 'kuzzle-plugin-commons';
-import { DeviceManagerConfig, DeviceManagerPlugin } from '../DeviceManagerPlugin';
-import { AssetMappingsManager } from './CustomMappings/AssetMappingsManager';
-import { DeviceMappingsManager } from './CustomMappings/DeviceMappingsManager';
+import { AbstractEngine, ConfigManager } from 'kuzzle-plugin-commons';
+import { DeviceManagerConfiguration } from '../types';
+import { DeviceManagerPlugin } from '../DeviceManagerPlugin';
+import { AssetsRegister } from './registers/AssetsRegister';
+import { DevicesRegister } from './registers/DevicesRegister';
+import { MeasuresRegister } from './registers/MeasuresRegister';
 export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlugin> {
-    config: DeviceManagerConfig;
-    private assetMappings;
-    private deviceMappings;
-    constructor(plugin: Plugin, assetMappings: AssetMappingsManager, deviceMappings: DeviceMappingsManager);
+    config: DeviceManagerConfiguration;
+    private assetsRegister;
+    private devicesRegister;
+    private measuresRegister;
+    constructor(plugin: Plugin, assetsRegister: AssetsRegister, devicesRegister: DevicesRegister, measuresRegister: MeasuresRegister, adminConfigManager: ConfigManager, engineConfigManager: ConfigManager);
     onCreate(index: string, group?: string): Promise<{
         collections: string[];
     }>;
@@ -17,5 +20,4 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
     onDelete(index: string): Promise<{
         collections: string[];
     }>;
-    private getAssetsHistoryMappings;
 }

package/lib/core-classes/DeviceManagerEngine.js

@@ -2,62 +2,50 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceManagerEngine = void 0;
 const kuzzle_plugin_commons_1 = require("kuzzle-plugin-commons");
-const models_1 = require("../models");
 class DeviceManagerEngine extends kuzzle_plugin_commons_1.AbstractEngine {
-    constructor(plugin, assetMappings, deviceMappings) {
-        super('device-manager', plugin, plugin.config.adminIndex, plugin.config.configCollection);
-        this.assetMappings = assetMappings;
-        this.deviceMappings = deviceMappings;
+    constructor(plugin, assetsRegister, devicesRegister, measuresRegister, adminConfigManager, engineConfigManager) {
+        super('device-manager', plugin, plugin.config.adminIndex, adminConfigManager, engineConfigManager);
+        this.context = plugin.context;
+        this.assetsRegister = assetsRegister;
+        this.devicesRegister = devicesRegister;
+        this.measuresRegister = measuresRegister;
     }
     async onCreate(index, group = 'commons') {
         const promises = [];
         promises.push(this.sdk.collection.create(index, 'assets', {
-            mappings: this.assetMappings.get(group)
-        }));
-        promises.push(this.sdk.collection.create(index, 'asset-history', {
-            mappings: this.getAssetsHistoryMappings(group)
+            mappings: this.assetsRegister.getMappings(group)
         }));
         promises.push(this.sdk.collection.create(index, 'devices', {
-            mappings: this.deviceMappings.get()
+            mappings: this.devicesRegister.getMappings()
         }));
-        promises.push(this.sdk.collection.create(index, this.config.configCollection, {
-            mappings: {
-                dynamic: 'strict',
-                properties: {
-                    type: { type: 'keyword' },
-                    catalog: models_1.catalogMappings,
-                }
-            }
+        promises.push(this.sdk.collection.create(index, 'measures', {
+            mappings: this.measuresRegister.getMappings()
         }));
+        promises.push(this.engineConfigManager.createCollection(index));
         await Promise.all(promises);
-        return { collections: ['assets', 'asset-history', this.config.configCollection, 'devices'] };
+        return { collections: ['assets', this.engineConfigManager.collection, 'devices', 'measures'] };
     }
     async onUpdate(index, group = 'commons') {
         const promises = [];
         promises.push(this.sdk.collection.create(index, 'assets', {
-            mappings: this.assetMappings.get(group)
-        }));
-        promises.push(this.sdk.collection.create(index, 'asset-history', {
-            mappings: this.getAssetsHistoryMappings(group)
+            mappings: this.assetsRegister.getMappings(group)
         }));
         promises.push(this.sdk.collection.create(index, 'devices', {
-            mappings: this.deviceMappings.get()
+            mappings: this.devicesRegister.getMappings()
+        }));
+        promises.push(this.sdk.collection.create(index, 'measures', {
+            mappings: this.measuresRegister.getMappings()
         }));
         await Promise.all(promises);
-        return { collections: ['assets', 'asset-history', 'devices'] };
+        return { collections: ['assets', 'devices', 'measures'] };
     }
     async onDelete(index) {
         const promises = [];
         promises.push(this.sdk.collection.delete(index, 'assets'));
-        promises.push(this.sdk.collection.delete(index, 'asset-history'));
         promises.push(this.sdk.collection.delete(index, 'devices'));
+        promises.push(this.sdk.collection.delete(index, 'measures'));
         await Promise.all(promises);
-        return { collections: ['assets', 'asset-history', 'devices'] };
-    }
-    getAssetsHistoryMappings(group) {
-        const mappings = JSON.parse(JSON.stringify(this.config.collections['asset-history']));
-        mappings.properties.asset = this.assetMappings.get(group);
-        return mappings;
+        return { collections: ['assets', 'devices', 'measures'] };
     }
 }
 exports.DeviceManagerEngine = DeviceManagerEngine;

package/lib/core-classes/DeviceService.d.ts

@@ -1,41 +1,98 @@
-import { JSONObject, EmbeddedSDK, Plugin } from 'kuzzle';
-import { DeviceBulkContent, DeviceMAttachementContent } from '../types';
-import { Decoder } from './Decoder';
-import { Device } from '../models';
+import { KDocument } from 'kuzzle-sdk';
+import { JSONObject, Plugin } from 'kuzzle';
+import { BaseAsset, Device } from '../models';
+import { DeviceContent } from '../types';
+import { mResponse } from '../utils/';
+export declare type DeviceBulkContent = {
+    engineId?: string;
+    deviceId: string;
+    assetId?: string;
+};
+/**
+ * Represents a request to link a device to an asset
+ *
+ * @example
+ * {
+ *   deviceId: 'Abeeway-4263232',
+ *   assetId: 'container-xlarger-HSZJSZ',
+ *   measuresNames: {
+ *     temperature: 'External temperature',
+ *     position: 'Lora Position'
+ *   }
+ * }
+ */
+export declare type LinkRequest = {
+    assetId: string;
+    deviceId: string;
+    /**
+     * List of measures names when linked to the asset.
+     * Default measure name is measure type.
+     */
+    measuresNames?: {
+        [measureType: string]: string;
+    };
+};
+export declare type AttachRequest = {
+    deviceId: string;
+    engineId: string;
+};
 export declare class DeviceService {
     private config;
     private context;
-    private decoders;
-    get sdk(): EmbeddedSDK;
-    constructor(plugin: Plugin, decoders: Map<string, Decoder>);
-    mAttach(devices: Device[], bulkData: DeviceBulkContent[], { strict, options }: {
+    private get sdk();
+    constructor(plugin: Plugin);
+    /**
+     * Create a new device.
+     *
+     * If the engineId is not the administration one, then the device will be
+     * automatically attached to the one provided.
+     *
+     * If an assetId is provided, then the device will be linked to this asset.
+     *
+     * @param engineId If it's not the admin engine, then the device will be attached to this one
+     * @param deviceContent Content of the device to create
+     */
+    create(engineId: string, deviceContent: DeviceContent, assetId: string, { refresh }: {
+        refresh?: any;
+    }): Promise<KDocument<DeviceContent>>;
+    attachEngine(attachRequest: AttachRequest, { refresh, strict }: {
+        refresh?: any;
         strict?: boolean;
-        options?: JSONObject;
-    }): Promise<DeviceMAttachementContent>;
-    mDetach(devices: Device[], bulkData: DeviceBulkContent[], { strict, options }: {
+    }): Promise<Device>;
+    detachEngine(deviceId: string, { refresh, strict }: {
+        refresh?: any;
         strict?: boolean;
-        options?: JSONObject;
+    }): Promise<Device>;
+    /**
+     * Link a device to an asset and copy device measures into the asset.
+     *
+     * Each measures will be given a distinct name when copied into the asset
+     */
+    linkAsset(linkRequest: LinkRequest, { refresh }: {
+        refresh?: any;
     }): Promise<{
-        errors: any[];
-        successes: any[];
+        asset: BaseAsset;
+        device: Device;
     }>;
-    mLink(devices: Device[], bulkData: DeviceBulkContent[], { strict, options }: {
+    unlinkAsset(deviceId: string, { refresh, strict }: {
+        refresh?: any;
         strict?: boolean;
-        options?: JSONObject;
     }): Promise<{
-        errors: any[];
-        successes: any[];
+        asset: BaseAsset;
+        device: Device;
     }>;
-    mUnlink(devices: Device[], { strict, options }: {
+    importDevices(devices: JSONObject, { refresh, strict }: {
+        refresh?: any;
         strict?: boolean;
-        options?: JSONObject;
     }): Promise<{
         errors: any[];
         successes: any[];
     }>;
-    private eraseAssetMeasure;
+    importCatalog(catalog: JSONObject[], { refresh, strict }: {
+        refresh?: any;
+        strict?: boolean;
+    }): Promise<mResponse>;
+    private getAsset;
+    private getDevice;
     private tenantExists;
-    private buildBulkDevices;
-    private formatDevicesContent;
-    private writeToDatabase;
 }