kuzzle-device-manager 0.4.15 → 2.0.0-rc4

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

@@ -17,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,61 @@
-import { Plugin, PluginContext, JSONObject, EmbeddedSDK } from 'kuzzle';
-import { PayloadService, BatchWriter, 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 { Plugin, PluginContext, JSONObject, KuzzleRequest } from 'kuzzle';
+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;
-    protected payloadService: PayloadService;
+    private assetCategoryController;
+    private metadataController;
+    private treeNodeController;
+    private batchController;
+    private assetService;
+    private assetCategoryService;
+    private payloadService;
     private deviceManagerEngine;
     private deviceService;
-    private migrationService;
-    protected batchWriter: BatchWriter;
-    protected get sdk(): EmbeddedSDK;
+    private measuresService;
+    private decodersRegister;
+    private measuresRegister;
+    private devicesRegister;
+    private assetsRegister;
+    private adminConfigManager;
+    private engineConfigManager;
+    private get sdk();
+    /**
+     * Manager assets customization.
+     *
+     * @method register
+     */
+    get assets(): AssetsRegister;
+    /**
+     * Manage devices customization.
+     *
+     * @method registerMetadata
+     */
+    get devices(): DevicesRegister;
     /**
-     * List of registered decoders.
-     * Map<model, decoder>
+     * 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();
+    unknowPayload(request: KuzzleRequest): Promise<void>;
     /**
      * 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 +72,4 @@ export declare class DeviceManagerPlugin extends Plugin {
      */
     private initializeConfig;
     private pipeCheckEngine;
-    private generateConfigID;
 }

package/lib/DeviceManagerPlugin.js

@@ -9,139 +9,183 @@ 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");
+const AssetCategoryController_1 = require("./controllers/AssetCategoryController");
+const MetadataController_1 = require("./controllers/MetadataController");
+const AssetCategoryService_1 = require("./core-classes/AssetCategoryService");
+const MeasureService_1 = require("./core-classes/MeasureService");
 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 */
+        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);
     }
     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;
+    }
+    async unknowPayload(request) {
+        const body = request.getBody();
+        const device = request.getString('device');
+        const documentContent = {
+            deviceModel: device,
+            rawPayload: body
+        };
+        this.sdk.document.create('device-manager', 'payloads', documentContent);
     }
     /**
      * 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.assetCategoryService = new AssetCategoryService_1.AssetCategoryService(this);
+        this.batchController = new kuzzle_1.BatchController(this.sdk, {
+            interval: this.config.batchInterval
+        });
+        this.assetService = new core_classes_1.AssetService(this, this.batchController);
+        this.deviceService = new core_classes_1.DeviceService(this, this.batchController, this.assetService, this.decodersRegister);
+        this.measuresService = new MeasureService_1.MeasureService(this, this.batchController, this.deviceService, this.assetService, this.measuresRegister);
+        this.payloadService = new core_classes_1.PayloadService(this, this.batchController, this.measuresRegister, this.measuresService);
+        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.deviceService, this.assetCategoryService, this.measuresService);
         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.assetCategoryController = new AssetCategoryController_1.AssetCategoryController(this, this.assetCategoryService);
+        this.metadataController = new MetadataController_1.MetadataController(this, this.assetCategoryService);
+        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),
-        };
-        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.api['device-manager/decoders'] = this.decodersController.definition;
+        this.api['device-manager/assetCategory'] = this.assetCategoryController.definition;
+        this.api['device-manager/metadata'] = this.metadataController.definition;
+        this.api['device-manager/payload'].actions.generic = {
+            handler: this.unknowPayload.bind(this),
+            http: [{ path: 'device-manager/payload/:device', verb: 'post' }]
         };
-        this.decoders.set(decoder.deviceModel, decoder);
-        return {
-            controller: 'device-manager/payload',
-            action: decoder.action,
+        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();
     }
     /**
      * Initialize the administration index of the plugin
@@ -164,19 +208,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 +234,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 +247,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/InternalCollection.d.ts

@@ -0,0 +1,5 @@
+export declare enum InternalCollection {
+    ASSETS = "assets",
+    DEVICES = "devices",
+    MEASURES = "measures"
+}

package/lib/InternalCollection.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalCollection = void 0;
+var InternalCollection;
+(function (InternalCollection) {
+    InternalCollection["ASSETS"] = "assets";
+    InternalCollection["DEVICES"] = "devices";
+    InternalCollection["MEASURES"] = "measures";
+})(InternalCollection = exports.InternalCollection || (exports.InternalCollection = {}));
+//# sourceMappingURL=InternalCollection.js.map

package/lib/controllers/AssetCategoryController.d.ts

@@ -0,0 +1,28 @@
+import { KuzzleRequest, Plugin } from 'kuzzle';
+import { RelationalController } from './RelationalController';
+import { ProcessedAssetCategoryContent } from '../types/AssetCategoryContent';
+import { AssetCategoryService } from '../core-classes/AssetCategoryService';
+export declare class AssetCategoryController extends RelationalController {
+    private assetCategoryService;
+    constructor(plugin: Plugin, assetCategoryService: AssetCategoryService);
+    create(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    update(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    delete(request: KuzzleRequest): Promise<string>;
+    linkParent(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    unlinkParent(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    unlinkMetadata(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    linkMetadata(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    get(request: KuzzleRequest): Promise<ProcessedAssetCategoryContent>;
+}