kuzzle-device-manager 0.4.13 → 2.0.0-rc3

package/lib/core-classes/PayloadService.js

@@ -7,23 +7,25 @@ exports.PayloadService = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const kuzzle_1 = require("kuzzle");
 const uuid_1 = require("uuid");
+const kuzzle_sdk_1 = require("kuzzle-sdk");
 const models_1 = require("../models");
-const utils_1 = require("../utils");
 class PayloadService {
-    constructor(plugin, batchWriter) {
+    constructor(plugin, measuresRegister) {
         this.config = plugin.config;
         this.context = plugin.context;
-        this.batchController = batchWriter.document;
+        this.measuresRegister = measuresRegister;
+        this.batch = new kuzzle_sdk_1.BatchController(this.sdk, {
+            interval: plugin.config.batchInterval
+        });
     }
     get sdk() {
         return this.context.accessors.sdk;
     }
+    get app() {
+        return global.app;
+    }
     async process(request, decoder, { refresh = undefined } = {}) {
-        const payload = request.input.body;
-        if (!payload
-            || (typeof payload === 'object' && Object.keys(payload).length === 0)) {
-            throw new kuzzle_1.BadRequestError('The body must contain the payload.');
-        }
+        const payload = request.getBody();
         const uuid = request.input.args.uuid || (0, uuid_1.v4)();
         let valid = true;
         try {
@@ -31,160 +33,166 @@ class PayloadService {
             if (!valid) {
                 return { valid };
             }
-            await decoder.beforeProcessing(payload, request);
         }
         catch (error) {
             valid = false;
             throw error;
         }
         finally {
-            await this.batchController.create(this.config.adminIndex, 'payloads', {
+            await this.batch.create(this.config.adminIndex, 'payloads', {
                 deviceModel: decoder.deviceModel,
+                payload,
                 uuid,
                 valid,
-                payload,
             }, uuid);
         }
-        const deviceContent = await decoder.decode(payload, request);
-        // Inject payload uuid
-        for (const measure of Object.values(deviceContent.measures)) {
-            if (!measure.payloadUuid) {
-                measure.payloadUuid = uuid;
-            }
+        const decodedPayload = await decoder.decode(payload, request);
+        const newMeasures = [];
+        const deviceId = models_1.Device.id(decoder.deviceModel, decodedPayload.reference);
+        for (const [type, measure] of Object.entries(decodedPayload.measures)) {
+            newMeasures.push({
+                measuredAt: measure.measuredAt,
+                origin: {
+                    assetId: null,
+                    id: deviceId,
+                    model: decoder.deviceModel,
+                    payloadUuids: [uuid],
+                    type: 'device',
+                },
+                type,
+                unit: this.measuresRegister.get(type).unit,
+                values: measure.values
+            });
         }
-        if (!deviceContent.model) {
-            deviceContent.model = decoder.deviceModel;
+        try {
+            const deviceDoc = await this.batch.get(this.config.adminIndex, 'devices', deviceId);
+            const device = new models_1.Device(deviceDoc._source);
+            if (device._source.assetId) {
+                for (const measure of newMeasures) {
+                    measure.origin.assetId = device._source.assetId;
+                }
+            }
+            return await this.update(device, newMeasures, { refresh });
         }
-        const device = new models_1.Device(deviceContent);
-        const exists = await this.batchController.exists(this.config.adminIndex, 'devices', device._id);
-        if (exists) {
-            return await this.update(device, decoder, request, { refresh });
+        catch (error) {
+            if (error.id === 'services.storage.not_found') {
+                return this.provisionning(decoder.deviceModel, decodedPayload.reference, newMeasures, { refresh });
+            }
+            throw error;
         }
-        return await this.deviceProvisionning(device, decoder, request, { refresh });
     }
-    async register(device, decoder, request, { refresh }) {
-        const enrichedDevice = await decoder.beforeRegister(device, request);
-        await this.batchController.create(this.config.adminIndex, 'devices', enrichedDevice._source, enrichedDevice._id, { refresh });
-        return await decoder.afterRegister(enrichedDevice, request);
+    async provisionning(model, reference, measures, { refresh }) {
+        const pluginConfig = await this.batch.get(this.config.adminIndex, this.config.adminCollections.config.name, 'plugin--device-manager');
+        const autoProvisioning = pluginConfig._source['device-manager'].provisioningStrategy === 'auto';
+        if (!autoProvisioning) {
+            throw new kuzzle_1.UnauthorizedError(`The device model "${model}" with reference "${reference}" is not registered on the platform.`);
+        }
+        const deviceId = models_1.Device.id(model, reference);
+        const deviceContent = {
+            measures,
+            model,
+            reference,
+        };
+        return this.register(deviceId, deviceContent, { refresh });
     }
     /**
-     * Device provisioning strategy.
-     *
-     * If autoProvisionning is on, device is automatically registered, otherwise
-     * we request the admin provisioning catalog to ensure this device is allowed
-     * to register.
-     *
-     * After registration, we look at the admin provisioning catalog entry to:
-     *   - attach the device to a tenant
-     *   - link the device to an asset of this tenant
-     *
-     * Then we look into the tenant provisioning catalog entry to:
-     *   - link the device to an asset of this tenant
+     * Register a new device by creating the document in admin index
+     * @todo add before/afterRegister events
      */
-    async deviceProvisionning(device, decoder, request, { refresh }) {
-        const pluginConfigDocument = await this.batchController.get(this.config.adminIndex, this.config.configCollection, 'plugin--device-manager');
-        const autoProvisionning = pluginConfigDocument._source['device-manager'].autoProvisionning;
-        const catalogEntry = await this.getCatalogEntry(this.config.adminIndex, device._id);
-        if (!autoProvisionning && !catalogEntry) {
-            throw new kuzzle_1.BadRequestError(`Device ${device._id} is not provisionned.`);
-        }
-        if (!autoProvisionning && catalogEntry.content.authorized === false) {
-            throw new kuzzle_1.BadRequestError(`Device ${device._id} is not allowed for registration.`);
-        }
-        const ret = await this.register(device, decoder, request, { refresh });
-        // If there is not auto attachment to a tenant then we cannot link asset as well
-        if (!catalogEntry || !catalogEntry.content.tenantId) {
-            return ret;
-        }
-        await this.sdk.query({
-            controller: 'device-manager/device',
-            action: 'attachTenant',
-            _id: device._id,
-            index: catalogEntry.content.tenantId,
-        });
-        if (catalogEntry.content.assetId) {
-            await this.sdk.query({
-                controller: 'device-manager/device',
-                action: 'linkAsset',
-                _id: device._id,
-                assetId: catalogEntry.content.assetId,
-            });
-        }
-        const tenantCatalogEntry = await this.getCatalogEntry(catalogEntry.content.tenantId, device._id);
-        if (tenantCatalogEntry
-            && tenantCatalogEntry.content.authorized !== false
-            && tenantCatalogEntry.content.assetId) {
-            await this.sdk.query({
-                controller: 'device-manager/device',
-                action: 'linkAsset',
-                _id: device._id,
-                assetId: tenantCatalogEntry.content.assetId,
-            });
-        }
-        return ret;
+    async register(deviceId, deviceContent, { refresh }) {
+        const deviceDoc = await this.batch.create(this.config.adminIndex, 'devices', deviceContent, deviceId, { refresh });
+        const device = new models_1.Device(deviceDoc._source);
+        return {
+            asset: null,
+            device: device.serialize(),
+            engineId: device._source.engineId,
+        };
     }
     /**
-     * Get the device entry from the provisioning catalog in corresponding index
+     * Updates the device with the new measures:
+     *  - in admin index
+     *  - in engine index
+     *  - in linked asset
+     *  - historize measures in engine index
+     *
+     * @todo add before/afterUpdate events
      */
-    async getCatalogEntry(index, deviceId) {
-        try {
-            const document = await this.batchController.get(index, this.config.configCollection, `catalog--${deviceId}`);
-            return new models_1.Catalog(document);
-        }
-        catch (error) {
-            if (error.id !== 'services.storage.not_found') {
-                throw error;
-            }
-            return null;
-        }
-    }
-    async update(device, decoder, request, { refresh }) {
+    async update(device, newMeasures, { refresh }) {
         const refreshableCollections = [];
-        const previousDevice = await this.batchController.get(this.config.adminIndex, 'devices', device._id);
-        const enrichedDevice = await decoder.beforeUpdate(device, request);
-        const deviceDocument = await this.batchController.update(this.config.adminIndex, 'devices', enrichedDevice._id, enrichedDevice._source, { source: true, retryOnConflict: 10 });
-        const updatedDevice = new models_1.Device(deviceDocument._source, deviceDocument._id);
+        const updatedDevice = await this.updateDevice(device, newMeasures);
         refreshableCollections.push([this.config.adminIndex, 'devices']);
-        const tenantId = previousDevice._source.tenantId;
+        const engineId = updatedDevice._source.engineId;
         let updatedAsset = null;
         // Propagate device into tenant index
-        if (tenantId) {
-            await this.batchController.update(tenantId, 'devices', enrichedDevice._id, enrichedDevice._source, { retryOnConflict: 10 });
-            refreshableCollections.push([tenantId, 'devices']);
+        if (engineId) {
+            await this.historizeMeasures(engineId, newMeasures);
+            await this.batch.update(engineId, 'devices', updatedDevice._id, updatedDevice._source, { retryOnConflict: 10 });
+            refreshableCollections.push([engineId, 'devices']);
             // Propagate measures into linked asset
-            const assetId = previousDevice._source.assetId;
+            const assetId = updatedDevice._source.assetId;
             if (assetId) {
-                updatedAsset = await this.propagateToAsset(tenantId, decoder, updatedDevice, assetId);
-                await this.historizeAsset(tenantId, updatedAsset);
-                refreshableCollections.push([tenantId, 'assets']);
+                updatedAsset = await this.propagateToAsset(engineId, newMeasures, assetId);
+                refreshableCollections.push([engineId, 'assets']);
             }
         }
         if (refresh === 'wait_for') {
             await Promise.all(refreshableCollections.map(([index, collection]) => (this.sdk.collection.refresh(index, collection))));
         }
-        return decoder.afterUpdate(updatedDevice, updatedAsset, request);
+        return {
+            asset: updatedAsset ? updatedAsset.serialize() : null,
+            device: device.serialize(),
+            engineId,
+        };
+    }
+    /**
+     * Updates a device with the new measures
+     *
+     * @returns Updated device
+     */
+    async updateDevice(device, newMeasures) {
+        // dup array reference
+        const measures = newMeasures.map(m => m);
+        // Keep previous measures that were not updated
+        for (const previousMeasure of device._source.measures) {
+            if (!measures.find(m => m.type === previousMeasure.type)) {
+                measures.push(previousMeasure);
+            }
+        }
+        device._source.measures = measures;
+        const result = await global.app.trigger(`engine:${device._source.engineId}:device:measures:new`, { device, measures: newMeasures });
+        const deviceDocument = await this.batch.update(this.config.adminIndex, 'devices', result.device._id, result.device._source, { retryOnConflict: 10, source: true });
+        return new models_1.Device(deviceDocument._source);
     }
     /**
-     * Propagate the measures inside the asset document.
+     * Save measures in engine "measures" collection
      */
-    async propagateToAsset(tenantId, decoder, updatedDevice, assetId) {
-        const measures = await decoder.copyToAsset(updatedDevice);
-        const measureTypes = Object.keys(measures);
-        const asset = await this.batchController.get(tenantId, 'assets', assetId);
-        asset._source.measures = lodash_1.default.merge(asset._source.measures, measures);
-        const { result } = await global.app.trigger(`engine:${tenantId}:asset:measures:new`, (0, utils_1.eventPayload)({ asset, measureTypes }));
-        const assetDocument = await this.batchController.update(tenantId, 'assets', assetId, result.asset._source, { source: true, retryOnConflict: 10 });
-        return new models_1.BaseAsset(assetDocument._source, assetDocument._id);
+    async historizeMeasures(engineId, measures) {
+        await Promise.all(measures.map(measure => {
+            return this.batch.create(engineId, 'measures', measure);
+        }));
     }
     /**
-     * Creates an history entry for an asset
+     * Propagate the measures inside the linked asset document.
      */
-    async historizeAsset(tenantId, asset) {
-        await this.batchController.create(tenantId, 'asset-history', {
-            assetId: asset._id,
-            measureTypes: Object.keys(asset._source.measures),
-            asset: lodash_1.default.omit(asset._source, ['_kuzzle_info']),
-        });
+    async propagateToAsset(engineId, newMeasures, assetId) {
+        // dup array reference
+        const measures = newMeasures.map(m => m);
+        const asset = await this.batch.get(engineId, 'assets', assetId);
+        if (!lodash_1.default.isArray(asset._source.measures)) {
+            throw new kuzzle_1.BadRequestError(`Asset "${assetId}" measures property is not an array.`);
+        }
+        // Keep previous measures that were not updated
+        // array are updated in place so we need to keep previous elements
+        for (const previousMeasure of asset._source.measures) {
+            if (!measures.find(m => m.type === previousMeasure.type)) {
+                measures.push(previousMeasure);
+            }
+        }
+        asset._source.measures = measures;
+        // Give the list of new measures types in event payload
+        const result = await global.app.trigger(`engine:${engineId}:asset:measures:new`, { asset, measures: newMeasures });
+        const assetDocument = await this.batch.update(engineId, 'assets', assetId, result.asset._source, { retryOnConflict: 10, source: true });
+        return new models_1.BaseAsset(assetDocument._source, assetDocument._id);
     }
 }
 exports.PayloadService = PayloadService;

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

@@ -1,8 +1,9 @@
 export * from './PayloadService';
 export * from './DeviceManagerEngine';
 export * from './DeviceService';
-export * from './MigrationService';
-export * from './BatchProcessing';
 export * from './Decoder';
-export * from './CustomMappings/AssetMappingsManager';
-export * from './CustomMappings/DeviceMappingsManager';
+export * from './AssetService';
+export * from './registers/AssetsRegister';
+export * from './registers/DevicesRegister';
+export * from './registers/MeasuresRegister';
+export * from './registers/DecodersRegister';

package/lib/core-classes/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,9 +17,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./PayloadService"), exports);
 __exportStar(require("./DeviceManagerEngine"), exports);
 __exportStar(require("./DeviceService"), exports);
-__exportStar(require("./MigrationService"), exports);
-__exportStar(require("./BatchProcessing"), exports);
 __exportStar(require("./Decoder"), exports);
-__exportStar(require("./CustomMappings/AssetMappingsManager"), exports);
-__exportStar(require("./CustomMappings/DeviceMappingsManager"), exports);
+__exportStar(require("./AssetService"), exports);
+__exportStar(require("./registers/AssetsRegister"), exports);
+__exportStar(require("./registers/DevicesRegister"), exports);
+__exportStar(require("./registers/MeasuresRegister"), exports);
+__exportStar(require("./registers/DecodersRegister"), exports);
 //# sourceMappingURL=index.js.map

package/lib/core-classes/{CustomMappings/AssetMappingsManager.d.ts → registers/AssetsRegister.d.ts}

@@ -1,11 +1,11 @@
 import { JSONObject } from 'kuzzle';
-import { DeviceMappingsManager } from './DeviceMappingsManager';
-export declare class AssetMappingsManager {
+import { MeasuresRegister } from './MeasuresRegister';
+export declare class AssetsRegister {
     private baseMappings;
-    private deviceMappings;
+    private measuresRegister;
     private assetByName;
     private assetByGroup;
-    constructor(baseMappings: JSONObject, deviceMappings: DeviceMappingsManager);
+    constructor(measuresRegister: MeasuresRegister);
     /**
      * Register an asset type with custom metadata.
      *
@@ -16,16 +16,15 @@ export declare class AssetMappingsManager {
      * @param metadata Asset type custom metadata
      * @param options.group Only inject this asset type to engine of this group
      *
-     * @example
-     *
+     * ```js
      * plugin.assets.register('container', {
      *   size: { type: 'integer' },
      *   serial: { type: 'keyword' },
      * });
-     *
+     * ```
      */
-    register(name: string, metadata: JSONObject, { group }?: {
+    register(type: string, metadata: JSONObject, { group }?: {
         group?: string;
     }): void;
-    get(group?: string): JSONObject;
+    getMappings(group?: string): JSONObject;
 }

package/lib/core-classes/{CustomMappings/AssetMappingsManager.js → registers/AssetsRegister.js}

@@ -3,15 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssetMappingsManager = void 0;
+exports.AssetsRegister = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const kuzzle_1 = require("kuzzle");
-class AssetMappingsManager {
-    constructor(baseMappings, deviceMappings) {
+const mappings_1 = require("../../mappings");
+class AssetsRegister {
+    constructor(measuresRegister) {
         this.assetByName = new Map();
         this.assetByGroup = new Map();
-        this.baseMappings = baseMappings;
-        this.deviceMappings = deviceMappings;
+        this.baseMappings = JSON.parse(JSON.stringify(mappings_1.assetsMappings));
+        this.measuresRegister = measuresRegister;
         this.assetByGroup.set('commons', []);
     }
     /**
@@ -24,44 +25,32 @@ class AssetMappingsManager {
      * @param metadata Asset type custom metadata
      * @param options.group Only inject this asset type to engine of this group
      *
-     * @example
-     *
+     * ```js
      * plugin.assets.register('container', {
      *   size: { type: 'integer' },
      *   serial: { type: 'keyword' },
      * });
-     *
+     * ```
      */
-    register(name, metadata, { group = 'commons' } = {}) {
-        if (this.assetByName.has(name)) {
-            throw new kuzzle_1.PluginImplementationError(`Asset of type "${name}" has already been registered.`);
+    register(type, metadata, { group = 'commons' } = {}) {
+        if (this.assetByName.has(type)) {
+            throw new kuzzle_1.PluginImplementationError(`Asset of type "${type}" has already been registered.`);
         }
         const definition = {
-            name,
             group,
             metadata,
+            type,
         };
-        this.assetByName.set(name, definition);
+        this.assetByName.set(type, definition);
         if (!this.assetByGroup.has(group)) {
             this.assetByGroup.set(group, []);
         }
         this.assetByGroup.get(group).push(definition);
     }
-    get(group = 'commons') {
+    getMappings(group = 'commons') {
         const mappings = JSON.parse(JSON.stringify(this.baseMappings));
-        const deviceMappings = this.deviceMappings.get();
         mappings.properties.measures.dynamic = 'false';
-        for (const [name, measure] of Object.entries(deviceMappings.properties.measures.properties)) {
-            mappings.properties.measures.properties[name] = {
-                properties: {
-                    id: { type: 'keyword' },
-                    model: { type: 'keyword' },
-                    reference: { type: 'keyword' },
-                    qos: deviceMappings.properties.qos,
-                    ...measure.properties,
-                }
-            };
-        }
+        mappings.properties.measures = this.measuresRegister.getMappings();
         if (this.assetByGroup.has('commons')) {
             for (const definition of this.assetByGroup.get('commons')) {
                 mappings.properties.metadata.properties = lodash_1.default.merge({}, mappings.properties.metadata.properties, definition.metadata);
@@ -75,5 +64,5 @@ class AssetMappingsManager {
         return mappings;
     }
 }
-exports.AssetMappingsManager = AssetMappingsManager;
-//# sourceMappingURL=AssetMappingsManager.js.map
+exports.AssetsRegister = AssetsRegister;
+//# sourceMappingURL=AssetsRegister.js.map

package/lib/core-classes/registers/DecodersRegister.d.ts

@@ -0,0 +1,46 @@
+import { ControllerDefinition, PluginContext } from 'kuzzle';
+import { Decoder } from '../Decoder';
+import { DecoderContent } from '../../types/DecoderContent';
+import { PayloadService } from '../PayloadService';
+export declare class DecodersRegister {
+    private context;
+    private _decoders;
+    private get sdk();
+    get decoders(): Decoder[];
+    init(context: PluginContext): void;
+    list(): Promise<DecoderContent[]>;
+    /**
+     * 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
+     *
+     * @param decoder Instantiated decoder
+     *
+     * @returns Corresponding API action requestPayload
+     */
+    register(decoder: Decoder): {
+        action: string;
+        controller: string;
+    };
+    /**
+     * Build the PayloadController with registered decoders
+     *
+     * @todo generate OpenAPI specification
+     *
+     * @internal
+     */
+    getPayloadController(payloadService: PayloadService): ControllerDefinition;
+    printDecoders(): void;
+    /**
+     * Creates default roles, profiles and users associated to the generated actions
+     * in the Payload controller.
+     *
+     * This method never returns a rejected promise.
+     */
+    createDefaultRights(): Promise<void>;
+    private createDefaultUsers;
+    private createDefaultProfiles;
+    private createDefaultRoles;
+}