kuzzle-device-manager 0.4.13 → 2.0.0-rc3

package/index.d.ts

@@ -1,4 +1,5 @@
 export * from './lib/DeviceManagerPlugin';
 export * from './lib/core-classes';
 export * from './lib/models';
+export * from './lib/measures';
 export * from './lib/types';

package/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -13,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lib/DeviceManagerPlugin"), exports);
 __exportStar(require("./lib/core-classes"), exports);
 __exportStar(require("./lib/models"), exports);
+__exportStar(require("./lib/measures"), exports);
 __exportStar(require("./lib/types"), exports);
 //# sourceMappingURL=index.js.map

package/lib/DeviceManagerPlugin.d.ts

@@ -1,85 +1,54 @@
 import { Plugin, PluginContext, JSONObject } from 'kuzzle';
-import { Decoder, PayloadHandler, AssetMappingsManager, DeviceMappingsManager } from './core-classes';
-export declare type DeviceManagerConfig = {
-    /**
-     * Administration index name
-     */
-    adminIndex: string;
-    /**
-     * Config collection name (in admin index)
-     */
-    configCollection: string;
-    /**
-     * Administration collections mappings (in admin index)
-     */
-    adminCollections: {
-        config: JSONObject;
-        devices: JSONObject;
-        payloads: JSONObject;
-    };
-    /**
-     * Tenants collections
-     */
-    collections: {
-        assets: JSONObject;
-        devices: JSONObject;
-        'asset-history': JSONObject;
-    };
-    /**
-     * Interval to write documents from the buffer
-     */
-    writerInterval: number;
-};
+import { AssetsRegister, DevicesRegister, MeasuresRegister, DecodersRegister } from './core-classes';
+import { DeviceManagerConfiguration } from './types';
 export declare class DeviceManagerPlugin extends Plugin {
-    config: DeviceManagerConfig;
-    private defaultConfig;
+    config: DeviceManagerConfiguration;
     private assetController;
     private deviceController;
+    private decodersController;
     private engineController;
+    private assetService;
     private payloadService;
     private deviceManagerEngine;
     private deviceService;
-    private migrationService;
-    private batchWriter;
+    private decodersRegister;
+    private measuresRegister;
+    private devicesRegister;
+    private assetsRegister;
+    private adminConfigManager;
+    private engineConfigManager;
     private get sdk();
     /**
-     * List of registered decoders.
-     * Map<model, decoder>
+     * Manager assets customization.
+     *
+     * @method register
+     */
+    get assets(): AssetsRegister;
+    /**
+     * Manage devices customization.
+     *
+     * @method registerMetadata
+     */
+    get devices(): DevicesRegister;
+    /**
+     * Manage measures customization.
+     *
+     * @method register
+     * @method get
      */
-    private decoders;
-    private deviceMappings;
-    private assetMappings;
-    get assets(): AssetMappingsManager;
-    get devices(): DeviceMappingsManager;
+    get measures(): MeasuresRegister;
     /**
-     * Constructor
+     * Manage decoders customization.
+     *
+     * @method register
+     * @method list
      */
+    get decoders(): DecodersRegister;
     constructor();
     /**
      * Init the plugin
      */
     init(config: JSONObject, context: PluginContext): Promise<void>;
-    /**
-     * Registers a new decoder for a device model.
-     *
-     * This will register a new API action:
-     *  - controller: `"device-manager/payload"`
-     *  - action: `action` property of the decoder or the device model in kebab-case
-     *
-     * If a custom payload handler is given then it will be used to process payloads
-     * instead of the PayloadService.process method.
-     *
-     * @param decoder Instantiated decoder
-     * @param options.handler Custom payload handler
-     *
-     * @returns Corresponding API action requestPayload
-     */
-    registerDecoder(decoder: Decoder, { handler }?: {
-        handler?: PayloadHandler;
-    }): {
-        controller: string;
-        action: string;
-    };
     /**
      * Initialize the administration index of the plugin
      */
@@ -96,5 +65,4 @@ export declare class DeviceManagerPlugin extends Plugin {
      */
     private initializeConfig;
     private pipeCheckEngine;
-    private generateConfigID;
 }

package/lib/DeviceManagerPlugin.js

@@ -9,139 +9,157 @@ const kuzzle_1 = require("kuzzle");
 const kuzzle_plugin_commons_1 = require("kuzzle-plugin-commons");
 const controllers_1 = require("./controllers");
 const core_classes_1 = require("./core-classes");
-const models_1 = require("./models");
+const measures_1 = require("./measures");
+const mappings_1 = require("./mappings");
 class DeviceManagerPlugin extends kuzzle_1.Plugin {
-    /**
-     * Constructor
-     */
     constructor() {
         super({
-            kuzzleVersion: '>=2.14.0 <3'
+            kuzzleVersion: '>=2.16.8 <3'
         });
-        /**
-         * List of registered decoders.
-         * Map<model, decoder>
-         */
-        this.decoders = new Map();
-        this.deviceMappings = new core_classes_1.DeviceMappingsManager(models_1.devicesMappings);
-        this.assetMappings = new core_classes_1.AssetMappingsManager(models_1.assetsMappings, this.deviceMappings);
+        this.decodersRegister = new core_classes_1.DecodersRegister();
+        this.measuresRegister = new core_classes_1.MeasuresRegister();
+        this.devicesRegister = new core_classes_1.DevicesRegister(this.measuresRegister);
+        this.assetsRegister = new core_classes_1.AssetsRegister(this.measuresRegister);
         this.api = {
             'device-manager/payload': {
                 actions: {}
             }
         };
-        this.defaultConfig = {
+        /* eslint-disable sort-keys */
+        this.config = {
             adminIndex: 'device-manager',
-            configCollection: 'config',
             adminCollections: {
                 config: {
-                    dynamic: 'strict',
-                    properties: {
-                        type: { type: 'keyword' },
-                        engine: {
-                            properties: {
-                                index: { type: 'keyword' },
-                                group: { type: 'keyword' },
-                            }
-                        },
-                        catalog: models_1.catalogMappings,
-                        'device-manager': {
-                            properties: {
-                                autoProvisionning: { type: 'boolean' },
-                            }
-                        }
-                    }
+                    name: 'config',
+                    mappings: {
+                        dynamic: 'strict',
+                        properties: {}
+                    },
+                    settings: {},
+                },
+                devices: {
+                    name: 'devices',
+                    mappings: mappings_1.devicesMappings,
+                    settings: {},
                 },
-                devices: models_1.devicesMappings,
                 payloads: {
-                    dynamic: 'strict',
-                    properties: {
-                        uuid: { type: 'keyword' },
-                        valid: { type: 'boolean' },
-                        deviceModel: { type: 'keyword' },
-                        payload: {
-                            dynamic: 'false',
-                            properties: {}
-                        }
-                    }
+                    name: 'payloads',
+                    mappings: mappings_1.payloadsMappings,
+                    settings: {},
                 }
             },
-            collections: {
-                assets: models_1.assetsMappings,
-                devices: models_1.devicesMappings,
-                'asset-history': models_1.assetsHistoryMappings,
+            engineCollections: {
+                config: {
+                    name: 'config',
+                    mappings: {
+                        dynamic: 'strict',
+                        properties: {}
+                    },
+                    settings: {}
+                }
             },
-            writerInterval: 50
+            batchInterval: 10
         };
+        /* eslint-enable sort-keys */
     }
     get sdk() {
         return this.context.accessors.sdk;
     }
+    /**
+     * Manager assets customization.
+     *
+     * @method register
+     */
     get assets() {
-        return this.assetMappings;
+        return this.assetsRegister;
     }
+    /**
+     * Manage devices customization.
+     *
+     * @method registerMetadata
+     */
     get devices() {
-        return this.deviceMappings;
+        return this.devicesRegister;
+    }
+    /**
+     * Manage measures customization.
+     *
+     * @method register
+     * @method get
+     */
+    get measures() {
+        return this.measuresRegister;
+    }
+    /**
+     * Manage decoders customization.
+     *
+     * @method register
+     * @method list
+     */
+    get decoders() {
+        return this.decodersRegister;
     }
     /**
      * Init the plugin
      */
     async init(config, context) {
-        this.config = lodash_1.default.merge({}, this.defaultConfig, config);
+        this.config = lodash_1.default.merge({}, this.config, config);
         this.context = context;
-        this.batchWriter = new core_classes_1.BatchWriter(this.sdk, { interval: this.config.writerInterval });
-        this.batchWriter.begin();
-        this.payloadService = new core_classes_1.PayloadService(this, this.batchWriter);
-        this.deviceService = new core_classes_1.DeviceService(this, this.decoders);
-        this.migrationService = new core_classes_1.MigrationService('device-manager', this);
-        this.deviceManagerEngine = new core_classes_1.DeviceManagerEngine(this, this.assetMappings, this.deviceMappings);
-        this.assetController = new controllers_1.AssetController(this);
+        /* eslint-disable sort-keys */
+        this.pipes = {
+            'device-manager/asset:before*': this.pipeCheckEngine.bind(this),
+            'device-manager/device:beforeAttachEngine': this.pipeCheckEngine.bind(this),
+            'device-manager/device:beforeSearch': this.pipeCheckEngine.bind(this),
+            'device-manager/device:beforeUpdate': this.pipeCheckEngine.bind(this),
+            'generic:document:beforeWrite': [],
+        };
+        /* eslint-enable sort-keys */
+        this.adminConfigManager = new kuzzle_plugin_commons_1.ConfigManager(this, {
+            mappings: this.config.adminCollections.config.mappings,
+            settings: this.config.adminCollections.config.settings,
+        });
+        this.adminConfigManager.register('device-manager', {
+            properties: {
+                provisioningStrategy: { type: 'keyword' },
+            }
+        });
+        this.adminConfigManager.register('engine', {
+            properties: {
+                group: { type: 'keyword' },
+                index: { type: 'keyword' },
+                name: { type: 'keyword' },
+            }
+        });
+        this.engineConfigManager = new kuzzle_plugin_commons_1.ConfigManager(this, {
+            mappings: this.config.engineCollections.config.mappings,
+            settings: this.config.engineCollections.config.settings,
+        });
+        this.measures.register('temperature', measures_1.temperatureMeasure);
+        this.measures.register('position', measures_1.positionMeasure);
+        this.measures.register('movement', measures_1.movementMeasure);
+        this.measures.register('humidity', measures_1.humidityMeasure);
+        this.measures.register('battery', measures_1.batteryMeasure);
+        this.assetService = new core_classes_1.AssetService(this);
+        this.payloadService = new core_classes_1.PayloadService(this, this.measuresRegister);
+        this.deviceService = new core_classes_1.DeviceService(this);
+        this.deviceManagerEngine = new core_classes_1.DeviceManagerEngine(this, this.assetsRegister, this.devicesRegister, this.measuresRegister, this.adminConfigManager, this.engineConfigManager);
+        this.decodersRegister.init(this.context);
+        this.assetController = new controllers_1.AssetController(this, this.assetService);
         this.deviceController = new controllers_1.DeviceController(this, this.deviceService);
+        this.decodersController = new controllers_1.DecodersController(this, this.decodersRegister);
         this.engineController = new kuzzle_plugin_commons_1.EngineController('device-manager', this, this.deviceManagerEngine);
+        this.api['device-manager/payload'] = this.decodersRegister.getPayloadController(this.payloadService);
         this.api['device-manager/asset'] = this.assetController.definition;
         this.api['device-manager/device'] = this.deviceController.definition;
-        this.pipes = {
-            'device-manager/device:beforeUpdate': this.pipeCheckEngine.bind(this),
-            'device-manager/device:beforeSearch': this.pipeCheckEngine.bind(this),
-            'device-manager/device:beforeAttachTenant': this.pipeCheckEngine.bind(this),
-            'device-manager/asset:before*': this.pipeCheckEngine.bind(this),
-            'document:beforeCreate': this.generateConfigID.bind(this),
+        this.api['device-manager/decoders'] = this.decodersController.definition;
+        this.hooks = {
+            'kuzzle:state:live': async () => {
+                await this.decodersRegister.createDefaultRights();
+                this.context.log.info('Default rights for payload controller has been registered.');
+            }
         };
+        this.decodersRegister.printDecoders();
         await this.initDatabase();
-        await this.migrationService.run();
-        for (const decoder of this.decoders.values()) {
-            this.context.log.info(`Register API action "device-manager/payload:${decoder.action}" with decoder "${decoder.constructor.name}" for device "${decoder.deviceModel}"`);
-        }
-    }
-    /**
-     * Registers a new decoder for a device model.
-     *
-     * This will register a new API action:
-     *  - controller: `"device-manager/payload"`
-     *  - action: `action` property of the decoder or the device model in kebab-case
-     *
-     * If a custom payload handler is given then it will be used to process payloads
-     * instead of the PayloadService.process method.
-     *
-     * @param decoder Instantiated decoder
-     * @param options.handler Custom payload handler
-     *
-     * @returns Corresponding API action requestPayload
-     */
-    registerDecoder(decoder, { handler } = {}) {
-        decoder.action = decoder.action || kuzzle_1.Inflector.kebabCase(decoder.deviceModel);
-        if (this.api['device-manager/payload'].actions[decoder.action]) {
-            throw new kuzzle_1.PluginImplementationError(`A decoder for "${decoder.deviceModel}" has already been registered.`);
-        }
-        this.api['device-manager/payload'].actions[decoder.action] = {
-            handler: request => handler ? handler(request, decoder) : this.payloadService.process(request, decoder),
-            http: decoder.http,
-        };
-        this.decoders.set(decoder.deviceModel, decoder);
-        return {
-            controller: 'device-manager/payload',
-            action: decoder.action,
-        };
     }
     /**
      * Initialize the administration index of the plugin
@@ -164,19 +182,21 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
                 }
             }
             await Promise.all([
-                this.sdk.collection.create(this.config.adminIndex, this.config.configCollection, this.config.adminCollections.config),
-                this.sdk.collection.create(this.config.adminIndex, 'devices', this.deviceMappings.get()),
-                this.sdk.collection.create(this.config.adminIndex, 'payloads', this.getPayloadsMappings()),
+                this.adminConfigManager.createCollection(this.config.adminIndex)
+                    .catch(error => {
+                    throw new kuzzle_1.PluginImplementationError(`Cannot create admin "config" collection: ${error}`);
+                }),
+                this.sdk.collection.create(this.config.adminIndex, 'devices', this.devicesRegister.getMappings())
+                    .catch(error => {
+                    throw new kuzzle_1.PluginImplementationError(`Cannot create admin "devices" collection: ${error}`);
+                }),
+                this.sdk.collection.create(this.config.adminIndex, 'payloads', this.getPayloadsMappings())
+                    .catch(error => {
+                    throw new kuzzle_1.PluginImplementationError(`Cannot create admin "payloads" collection: ${error}`);
+                }),
             ]);
             await this.initializeConfig();
         }
-        catch (error) {
-            // When nodes are starting at the same time, the index cache synchronization
-            // message is received too late so index.exists returns false
-            if (error.id !== 'services.storage.index_already_exists') {
-                throw error;
-            }
-        }
         finally {
             await mutex.unlock();
         }
@@ -188,8 +208,8 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
      * Those custom mappings allow to search raw payloads more efficiently.
      */
     getPayloadsMappings() {
-        const mappings = JSON.parse(JSON.stringify(this.config.adminCollections.payloads));
-        for (const decoder of this.decoders.values()) {
+        const { mappings } = JSON.parse(JSON.stringify(this.config.adminCollections.payloads));
+        for (const decoder of this.decodersRegister.decoders) {
             mappings.properties.payload.properties = {
                 ...mappings.properties.payload.properties,
                 ...decoder.payloadsMappings
@@ -201,35 +221,26 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
      * Initialize the config document if it does not exists
      */
     async initializeConfig() {
-        const exists = await this.sdk.document.exists(this.config.adminIndex, this.config.configCollection, 'plugin--device-manager');
+        const exists = await this.sdk.document.exists(this.config.adminIndex, this.adminConfigManager.collection, 'plugin--device-manager');
         if (!exists) {
-            await this.sdk.document.create(this.config.adminIndex, this.config.configCollection, {
-                type: 'device-manager',
-                'device-manager': { autoProvisionning: true }
+            await this.sdk.document.create(this.config.adminIndex, this.adminConfigManager.collection, {
+                'device-manager': { provisioningStrategy: 'auto' },
+                type: 'device-manager'
             }, 'plugin--device-manager');
         }
     }
     async pipeCheckEngine(request) {
-        const index = request.getIndex();
-        const { result: { exists } } = await this.sdk.query({
-            controller: 'device-manager/engine',
-            action: 'exists',
-            index,
-        });
-        if (!exists) {
-            throw new kuzzle_1.BadRequestError(`Tenant "${index}" does not have a device-manager engine`);
-        }
-        return request;
-    }
-    async generateConfigID(request) {
-        if (request.getCollection() !== this.config.configCollection) {
-            return request;
-        }
-        const document = request.getBody();
-        if (document.type !== 'catalog' || request.getId(({ ifMissing: 'ignore' }))) {
-            return request;
+        const engineId = request.getString('engineId');
+        if (engineId !== this.config.adminIndex) {
+            const { result: { exists } } = await this.sdk.query({
+                action: 'exists',
+                controller: 'device-manager/engine',
+                index: engineId,
+            });
+            if (!exists) {
+                throw new kuzzle_1.BadRequestError(`Tenant "${engineId}" does not have a device-manager engine`);
+            }
         }
-        request.input.args._id = `catalog--${document.catalog.deviceId}`;
         return request;
     }
 }

package/lib/controllers/AssetController.d.ts

@@ -1,7 +1,22 @@
-import { KuzzleRequest, EmbeddedSDK, Plugin } from 'kuzzle';
-import { CRUDController } from './CRUDController';
+import { CRUDController } from 'kuzzle-plugin-commons';
+import { KuzzleRequest, Plugin } from 'kuzzle';
+import { AssetService } from '../core-classes';
 export declare class AssetController extends CRUDController {
-    get sdk(): EmbeddedSDK;
-    constructor(plugin: Plugin);
-    create(request: KuzzleRequest): Promise<import("kuzzle").Document>;
+    private assetService;
+    private get sdk();
+    constructor(plugin: Plugin, assetService: AssetService);
+    measures(request: KuzzleRequest): Promise<{
+        measures: import("kuzzle").KDocument<import("../types").MeasureContent>[];
+    }>;
+    update(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    create(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    importAssets(request: KuzzleRequest): Promise<{
+        errors: any[];
+        successes: any[];
+    }>;
+    delete(request: KuzzleRequest): Promise<string>;
 }

package/lib/controllers/AssetController.js

@@ -1,52 +1,107 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetController = void 0;
-const CRUDController_1 = require("./CRUDController");
+const csvtojson_1 = __importDefault(require("csvtojson"));
+const kuzzle_plugin_commons_1 = require("kuzzle-plugin-commons");
+const kuzzle_1 = require("kuzzle");
 const BaseAsset_1 = require("../models/BaseAsset");
-class AssetController extends CRUDController_1.CRUDController {
-    get sdk() {
-        return this.context.accessors.sdk;
-    }
-    constructor(plugin) {
+class AssetController extends kuzzle_plugin_commons_1.CRUDController {
+    constructor(plugin, assetService) {
         super(plugin, 'assets');
+        this.assetService = assetService;
+        /* eslint-disable sort-keys */
         this.definition = {
             actions: {
                 create: {
                     handler: this.create.bind(this),
-                    http: [{ verb: 'post', path: 'device-manager/:index/assets' }],
-                },
-                update: {
-                    handler: this.update.bind(this),
-                    http: [{ verb: 'put', path: 'device-manager/:index/assets/:_id' }],
+                    http: [{ path: 'device-manager/:index/assets', verb: 'post' }],
                 },
                 delete: {
                     handler: this.delete.bind(this),
-                    http: [{ verb: 'delete', path: 'device-manager/:index/assets/:_id' }],
+                    http: [{ path: 'device-manager/:index/assets/:_id', verb: 'delete' }],
+                },
+                importAssets: {
+                    handler: this.importAssets.bind(this),
+                    http: [{ path: 'device-manager/:index/assets/_import', verb: 'post' }]
                 },
                 search: {
                     handler: this.search.bind(this),
                     http: [
-                        { verb: 'post', path: 'device-manager/:index/assets/_search' },
-                        { verb: 'get', path: 'device-manager/:index/assets/_search' },
+                        { path: 'device-manager/:index/assets/_search', verb: 'post' },
+                        { path: 'device-manager/:index/assets/_search', verb: 'get' },
                     ],
                 },
+                update: {
+                    handler: this.update.bind(this),
+                    http: [{ path: 'device-manager/:index/assets/:_id', verb: 'put' }],
+                },
+                measures: {
+                    handler: this.measures.bind(this),
+                    http: [{ path: 'device-manager/:index/assets/:_id/measures', verb: 'get' }],
+                }
             },
         };
+        /* eslint-enable sort-keys */
+    }
+    get sdk() {
+        return this.context.accessors.sdk;
+    }
+    async measures(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const size = request.input.args.size;
+        const startAt = request.input.args.startAt;
+        const endAt = request.input.args.endAt;
+        if (size && startAt || size && endAt) {
+            throw new kuzzle_1.BadRequestError('You cannot specify both a "size" and a "startAt" or "endAt"');
+        }
+        const measures = await this.assetService.measureHistory(engineId, id, { endAt, size, startAt });
+        return { measures };
+    }
+    async update(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const body = request.getBody();
+        const asset = await this.sdk.document.get(engineId, this.collection, id);
+        const response = await global.app.trigger('device-manager:asset:update:before', {
+            asset,
+            updates: body
+        });
+        request.input.args.index = engineId;
+        request.input.body = response.updates;
+        const result = await super.update(request);
+        await global.app.trigger('device-manager:asset:update:after', {
+            asset,
+            updates: result._source,
+        });
+        return result;
     }
     async create(request) {
         const type = request.getBodyString('type');
         const model = request.getBodyString('model');
         const reference = request.getBodyString('reference');
-        if (!request.input.resource._id) {
-            const assetContent = {
-                type,
-                model,
-                reference,
-            };
-            const asset = new BaseAsset_1.BaseAsset(assetContent);
-            request.input.resource._id = asset._id;
+        if (!request.input.args._id) {
+            request.input.args._id = BaseAsset_1.BaseAsset.id(type, model, reference);
         }
-        return await super.create(request);
+        request.input.args.index = request.getString('engineId');
+        return super.create(request);
+    }
+    async importAssets(request) {
+        const engineId = request.getString('engineId');
+        const content = request.getBodyString('csv');
+        const assets = await (0, csvtojson_1.default)({ delimiter: 'auto' }).fromString(content);
+        const results = await this.assetService.importAssets(engineId, assets, {
+            options: { ...request.input.args },
+            strict: true
+        });
+        return results;
+    }
+    async delete(request) {
+        request.input.args.index = request.getString('engineId');
+        return super.delete(request);
     }
 }
 exports.AssetController = AssetController;