kuzzle-device-manager 0.4.13 → 2.0.0-rc3

package/lib/core-classes/DeviceService.js

@@ -1,264 +1,222 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceService = void 0;
 const kuzzle_1 = require("kuzzle");
+const uuid_1 = require("uuid");
+const lodash_1 = __importDefault(require("lodash"));
+const models_1 = require("../models");
+const utils_1 = require("../utils/");
 class DeviceService {
-    constructor(plugin, decoders) {
+    constructor(plugin) {
         this.config = plugin.config;
         this.context = plugin.context;
-        this.decoders = decoders;
     }
     get sdk() {
         return this.context.accessors.sdk;
     }
-    async mAttach(devices, bulkData, { strict, options }) {
-        const attachedDevices = devices.filter(device => device._source.tenantId);
-        if (strict && attachedDevices.length > 0) {
-            const ids = attachedDevices.map(device => device._id).join(',');
-            throw new kuzzle_1.BadRequestError(`These devices "${ids}" are already attached to a tenant`);
+    /**
+     * 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
+     */
+    async create(engineId, deviceContent, assetId, { refresh }) {
+        const deviceId = models_1.Device.id(deviceContent.model, deviceContent.reference);
+        const device = await this.sdk.document.create(this.config.adminIndex, 'devices', deviceContent, deviceId, { refresh });
+        if (this.config.adminIndex === engineId) {
+            return device;
         }
-        const documents = this.buildBulkDevices(bulkData);
-        const results = {
-            errors: [],
-            successes: [],
-        };
-        for (let i = 0; i < documents.length; i++) {
-            const document = documents[i];
-            const tenantExists = await this.tenantExists(document.tenantId);
-            if (strict && !tenantExists) {
-                throw new kuzzle_1.BadRequestError(`Tenant "${document.tenantId}" does not have a device-manager engine`);
-            }
-            else if (!strict && !tenantExists) {
-                results.errors.push(`Tenant "${document.tenantId}" does not have a device-manager engine`);
-                continue;
-            }
-            const deviceDocuments = this.formatDevicesContent(devices, document);
-            const { errors, successes } = await this.writeToDatabase(deviceDocuments, async (deviceDocuments) => {
-                const updated = await this.sdk.document.mUpdate(this.config.adminIndex, 'devices', deviceDocuments, { strict, refresh: options.refresh });
-                await this.sdk.document.mCreate(document.tenantId, 'devices', deviceDocuments, { strict, refresh: options.refresh });
-                return {
-                    successes: results.successes.concat(updated.successes),
-                    errors: results.errors.concat(updated.errors)
-                };
-            });
-            results.successes.concat(successes);
-            results.errors.concat(errors);
+        const attachedDevice = await this.attachEngine({ deviceId, engineId }, { refresh, strict: true });
+        if (!assetId) {
+            return attachedDevice;
         }
-        return results;
+        const { device: linkedDevice } = await this.linkAsset({ assetId, deviceId }, { refresh });
+        return linkedDevice;
     }
-    async mDetach(devices, bulkData, { strict, options }) {
-        const detachedDevices = devices.filter(device => {
-            return !device._source.tenantId || device._source.tenantId === null;
-        });
-        if (strict && detachedDevices.length > 0) {
-            const ids = detachedDevices.map(device => device._id).join(',');
-            throw new kuzzle_1.BadRequestError(`Devices "${ids}" are not attached to a tenant`);
+    async attachEngine(attachRequest, { refresh, strict }) {
+        const device = await this.getDevice(attachRequest.deviceId);
+        if (strict && device._source.engineId) {
+            throw new kuzzle_1.BadRequestError(`Device "${device._id}" is already attached to an engine.`);
         }
-        const linkedAssets = devices.filter(device => device._source.assetId);
-        if (strict && linkedAssets.length > 0) {
-            const ids = linkedAssets.map(device => device._id).join(',');
-            throw new kuzzle_1.BadRequestError(`Devices "${ids}" are still linked to an asset`);
+        if (!await this.tenantExists(attachRequest.engineId)) {
+            throw new kuzzle_1.BadRequestError(`Engine "${attachRequest.engineId}" does not exists.`);
         }
-        const builder = bulkData.map(data => {
-            const { deviceId } = data;
-            const device = devices.find(s => s._id === deviceId);
-            return { tenantId: device._source.tenantId, deviceId };
+        device._source.engineId = attachRequest.engineId;
+        const response = await global.app.trigger('device-manager:device:attach-engine:before', {
+            device,
+            engineId: attachRequest.engineId,
         });
-        const documents = this.buildBulkDevices(builder);
-        const results = {
-            errors: [],
-            successes: [],
-        };
-        for (let i = 0; i < documents.length; i++) {
-            const document = documents[i];
-            const devicesContent = devices.filter(({ _id }) => document.deviceIds.includes(_id));
-            const deviceDocuments = devicesContent.map(device => {
-                return { _id: device._id, body: { tenantId: null } };
-            });
-            const { errors, successes } = await this.writeToDatabase(deviceDocuments, async (deviceDocuments) => {
-                const updated = await this.sdk.document.mUpdate(this.config.adminIndex, 'devices', deviceDocuments, { strict, refresh: options.refresh });
-                await this.sdk.document.mDelete(document.tenantId, 'devices', deviceDocuments.map(device => device._id), { strict, refresh: options.refresh });
-                return {
-                    successes: results.successes.concat(updated.successes),
-                    errors: results.errors.concat(updated.errors)
-                };
-            });
-            results.successes.concat(successes);
-            results.errors.concat(errors);
+        await Promise.all([
+            this.sdk.document.update(this.config.adminIndex, 'devices', response.device._id, { engineId: response.device._source.engineId }, { refresh }),
+            this.sdk.document.createOrReplace(response.device._source.engineId, 'devices', response.device._id, response.device._source, { refresh }),
+        ]);
+        await global.app.trigger('device-manager:device:attach-engine:after', {
+            device,
+            engineId: attachRequest.engineId,
+        });
+        return device;
+    }
+    async detachEngine(deviceId, { refresh, strict }) {
+        const device = await this.getDevice(deviceId);
+        const engineId = device._source.engineId;
+        if (strict && !engineId) {
+            throw new kuzzle_1.BadRequestError(`Device "${device._id}" is not attached to an engine.`);
         }
-        return results;
+        if (device._source.assetId) {
+            throw new kuzzle_1.BadRequestError(`Device "${device._id}" is still linked to an asset.`);
+        }
+        const response = await global.app.trigger('device-manager:device:detach-engine:before', {
+            device,
+            engineId,
+        });
+        await Promise.all([
+            this.sdk.document.update(this.config.adminIndex, 'devices', device._id, { engineId: null }, { refresh }),
+            this.sdk.document.delete(response.engineId, 'devices', device._id, { refresh }),
+        ]);
+        await global.app.trigger('device-manager:device:detach-engine:after', {
+            device,
+            engineId,
+        });
+        return device;
     }
-    async mLink(devices, bulkData, { strict, options }) {
-        const detachedDevices = devices.filter(device => {
-            return !device._source.tenantId || device._source.tenantId === null;
+    /**
+     * 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
+     */
+    async linkAsset(linkRequest, { refresh }) {
+        const device = await this.getDevice(linkRequest.deviceId);
+        const engineId = device._source.engineId;
+        if (!engineId) {
+            throw new kuzzle_1.BadRequestError(`Device "${device._id}" is not attached to an engine.`);
+        }
+        if (device._source.assetId) {
+            throw new kuzzle_1.BadRequestError(`Device "${device._id}" is already linked to an asset.`);
+        }
+        const asset = await this.getAsset(linkRequest.assetId, engineId);
+        if (!lodash_1.default.isArray(asset._source.measures)) {
+            throw new kuzzle_1.BadRequestError(`Asset "${linkRequest.assetId}" measures property is not an array.`);
+        }
+        // Copy device measures and assign measures names
+        const measures = (device._source.measures || []).map(measure => {
+            const name = lodash_1.default.get(linkRequest, `measuresNames.${measure.type}`, measure.type);
+            return { ...measure, name };
         });
-        if (strict && detachedDevices.length > 0) {
-            const ids = detachedDevices.map(device => device._id).join(',');
-            throw new kuzzle_1.PreconditionError(`Devices "${ids}" are not attached to a tenant`);
+        const newMeasuresNames = measures.map(m => m.name);
+        const duplicateMeasure = asset._source.measures.find(m => newMeasuresNames.includes(m.name));
+        if (duplicateMeasure) {
+            throw new kuzzle_1.BadRequestError(`Duplicate measure name "${duplicateMeasure.name}"`);
+        }
+        // Keep previous asset measures of different types
+        for (const previousMeasure of asset._source.measures) {
+            if (!measures.find(m => m.name === previousMeasure.name)) {
+                measures.push(previousMeasure);
+            }
+        }
+        asset._source.measures = measures;
+        device._source.assetId = linkRequest.assetId;
+        const response = await global.app.trigger('device-manager:device:link-asset:before', { asset, device });
+        await Promise.all([
+            this.sdk.document.update(this.config.adminIndex, 'devices', device._id, { assetId: response.device._source.assetId }, { refresh }),
+            this.sdk.document.update(engineId, 'devices', device._id, { assetId: response.device._source.assetId }, { refresh }),
+            this.sdk.document.update(engineId, 'assets', asset._id, { measures: response.asset._source.measures }, { refresh }),
+        ]);
+        await global.app.trigger('device-manager:device:link-asset:after', { asset, device });
+        return { asset, device };
+    }
+    async unlinkAsset(deviceId, { refresh, strict }) {
+        const device = await this.getDevice(deviceId);
+        const engineId = device._source.engineId;
+        if (strict && !engineId) {
+            throw new kuzzle_1.BadRequestError(`Device "${device._id}" is not attached to an engine.`);
+        }
+        if (!device._source.assetId) {
+            throw new kuzzle_1.BadRequestError(`Device "${device._id}" is not linked to an asset.`);
         }
-        const builder = bulkData.map(data => {
-            const { deviceId, assetId } = data;
-            const device = devices.find(s => s._id === deviceId);
-            return { tenantId: device._source.tenantId, deviceId, assetId };
+        const asset = await this.getAsset(device._source.assetId, engineId);
+        // @todo should be done by measure name and not type
+        asset._source.measures = asset._source.measures.filter(m => {
+            return !device._source.measures.find(dm => dm.type === m.type);
         });
-        const documents = this.buildBulkDevices(builder);
+        device._source.assetId = null;
+        const response = await global.app.trigger('device-manager:device:unlink-asset:before', { asset, device });
+        await Promise.all([
+            this.sdk.document.update(this.config.adminIndex, 'devices', device._id, { assetId: null }, { refresh }),
+            this.sdk.document.update(engineId, 'devices', device._id, { assetId: null }, { refresh }),
+            this.sdk.document.update(engineId, 'assets', asset._id, { measures: response.asset._source.measures }, { refresh }),
+        ]);
+        await global.app.trigger('device-manager:device:unlink-asset:before', { asset, device });
+        return { asset, device };
+    }
+    async importDevices(devices, { refresh, strict }) {
         const results = {
             errors: [],
             successes: [],
         };
-        for (let i = 0; i < documents.length; i++) {
-            const document = documents[i];
-            const existingAssets = await this.sdk.document.mGet(document.tenantId, 'assets', document.assetIds);
-            if (strict && existingAssets.errors.length > 0) {
-                throw new kuzzle_1.NotFoundError(`Assets "${existingAssets.errors}" do not exist`);
-            }
-            const devicesContent = devices.filter(({ _id }) => document.deviceIds.includes(_id));
-            const deviceDocuments = [];
-            const assetDocuments = [];
-            for (const device of devicesContent) {
-                const decoder = this.decoders.get(device._source.model);
-                const measures = await decoder.copyToAsset(device);
-                const { assetId } = bulkData.find(data => data.deviceId === device._id);
-                deviceDocuments.push({ _id: device._id, body: { assetId } });
-                assetDocuments.push({ _id: assetId, body: { measures } });
-            }
-            const updatedDevice = await this.writeToDatabase(deviceDocuments, async (deviceDocuments) => {
-                const updated = await this.sdk.document.mUpdate(this.config.adminIndex, 'devices', deviceDocuments, { strict, refresh: options.refresh });
-                await this.sdk.document.mUpdate(document.tenantId, 'devices', deviceDocuments, { strict, refresh: options.refresh });
-                return {
-                    successes: results.successes.concat(updated.successes),
-                    errors: results.errors.concat(updated.errors)
-                };
-            });
-            const updatedAssets = await this.writeToDatabase(assetDocuments, async (assetDocuments) => {
-                const updated = await this.sdk.document.mUpdate(document.tenantId, 'assets', assetDocuments, { strict, refresh: options.refresh });
-                return {
-                    successes: results.successes.concat(updated.successes),
-                    errors: results.errors.concat(updated.errors)
-                };
-            });
-            results.successes.concat(updatedDevice.successes, updatedAssets.successes);
-            results.errors.concat(updatedDevice.errors, updatedDevice.errors);
-        }
+        const deviceDocuments = devices
+            .map((device) => ({ _id: device._id || (0, uuid_1.v4)(), body: lodash_1.default.omit(device, ['_id']) }));
+        await (0, utils_1.writeToDatabase)(deviceDocuments, async (result) => {
+            const created = await this.sdk.document.mCreate('device-manager', 'devices', result, { refresh, strict });
+            return {
+                errors: results.errors.concat(created.errors),
+                successes: results.successes.concat(created.successes)
+            };
+        });
         return results;
     }
-    async mUnlink(devices, { strict, options }) {
-        const unlinkedDevices = devices.filter(device => !device._source.assetId);
-        if (strict && unlinkedDevices.length > 0) {
-            const ids = unlinkedDevices.map(d => d._id);
-            throw new kuzzle_1.BadRequestError(`Devices "${ids}" are not linked to an asset`);
-        }
-        const builder = devices.map(device => {
-            const { _id, _source } = device;
-            return { tenantId: _source.tenantId, deviceId: _id, assetId: _source.assetId };
-        });
-        const documents = this.buildBulkDevices(builder);
+    async importCatalog(catalog, { refresh, strict }) {
         const results = {
             errors: [],
             successes: [],
         };
-        for (let i = 0; i < documents.length; i++) {
-            const document = documents[i];
-            const devicesContent = devices.filter(({ _id }) => document.deviceIds.includes(_id));
-            const deviceDocuments = [];
-            const assetDocuments = [];
-            for (const device of devicesContent) {
-                deviceDocuments.push({ _id: device._id, body: { assetId: null } });
-                const measures = await this.eraseAssetMeasure(document.tenantId, device);
-                assetDocuments.push({ _id: device._source.assetId, body: { measures } });
-            }
-            const updatedDevice = await this.writeToDatabase(deviceDocuments, async (deviceDocuments) => {
-                const updated = await this.sdk.document.mUpdate(this.config.adminIndex, 'devices', deviceDocuments, { strict, refresh: options.refresh });
-                await this.sdk.document.mUpdate(document.tenantId, 'devices', deviceDocuments, { strict, refresh: options.refresh });
-                return {
-                    successes: results.successes.concat(updated.successes),
-                    errors: results.errors.concat(updated.errors)
-                };
-            });
-            const updatedAssets = await this.writeToDatabase(assetDocuments, async (assetDocuments) => {
-                const updated = await this.sdk.document.mUpdate(document.tenantId, 'assets', assetDocuments, { strict, refresh: options.refresh });
-                return {
-                    successes: results.successes.concat(updated.successes),
-                    errors: results.errors.concat(updated.errors)
-                };
-            });
-            results.successes.concat(updatedDevice.successes, updatedAssets.successes);
-            results.errors.concat(updatedDevice.errors, updatedDevice.errors);
+        const withoutIds = catalog.filter(content => !content.deviceId);
+        if (withoutIds.length > 0) {
+            throw new kuzzle_1.BadRequestError(`${withoutIds.length} Devices do not have an ID`);
         }
+        const catalogDocuments = catalog
+            .map((catalogContent) => ({
+            _id: `catalog--${catalogContent.deviceId}`,
+            body: {
+                catalog: {
+                    authorized: catalogContent.authorized === 'false' ? false : true,
+                    deviceId: catalogContent.deviceId,
+                },
+                type: 'catalog'
+            }
+        }));
+        await (0, utils_1.writeToDatabase)(catalogDocuments, async (result) => {
+            const created = await this.sdk.document.mCreate(this.config.adminIndex, this.config.adminCollections.config.name, result, { refresh, strict });
+            return {
+                errors: results.errors.concat(created.errors),
+                successes: results.successes.concat(created.successes)
+            };
+        });
         return results;
     }
-    async eraseAssetMeasure(tenantId, device) {
-        const { _source: { measures } } = await this.sdk.document.get(tenantId, 'assets', device._source.assetId);
-        for (const [measureName] of Object.entries(device._source.measures)) {
-            if (measures[measureName]) {
-                measures[measureName] = undefined;
-            }
-        }
-        return measures;
+    async getAsset(assetId, engineId) {
+        const document = await this.sdk.document.get(engineId, 'assets', assetId);
+        return new models_1.BaseAsset(document._source, document._id);
     }
-    async tenantExists(tenantId) {
+    async getDevice(deviceId) {
+        const document = await this.sdk.document.get(this.config.adminIndex, 'devices', deviceId);
+        return new models_1.Device(document._source, document._id);
+    }
+    async tenantExists(engineId) {
         const { result: tenantExists } = await this.sdk.query({
-            controller: 'device-manager/engine',
             action: 'exists',
-            index: tenantId,
+            controller: 'device-manager/engine',
+            index: engineId,
         });
         return tenantExists;
     }
-    buildBulkDevices(bulkData) {
-        const documents = [];
-        for (let i = 0; i < bulkData.length; i++) {
-            const { tenantId, deviceId, assetId } = bulkData[i];
-            const document = documents.find(doc => doc.tenantId === tenantId);
-            if (document) {
-                document.deviceIds.push(deviceId);
-                document.assetIds.push(assetId);
-            }
-            else {
-                documents.push({ tenantId, deviceIds: [deviceId], assetIds: [assetId] });
-            }
-        }
-        return documents;
-    }
-    formatDevicesContent(devices, document) {
-        const devicesContent = devices.filter(device => document.deviceIds.includes(device._id));
-        const devicesDocuments = devicesContent.map(device => {
-            device._source.tenantId = document.tenantId;
-            return { _id: device._id, body: device._source };
-        });
-        return devicesDocuments;
-    }
-    async writeToDatabase(deviceDocuments, writer) {
-        const results = {
-            errors: [],
-            successes: [],
-        };
-        const limit = global.kuzzle.config.limits.documentsWriteCount;
-        if (deviceDocuments.length <= limit) {
-            const { successes, errors } = await writer(deviceDocuments);
-            results.successes.push(successes);
-            results.errors.push(errors);
-            return results;
-        }
-        const writeMany = async (start, end) => {
-            const devices = deviceDocuments.slice(start, end);
-            const { successes, errors } = await writer(devices);
-            results.successes.push(successes);
-            results.errors.push(errors);
-        };
-        let offset = 0;
-        let offsetLimit = limit;
-        let done = false;
-        while (!done) {
-            await writeMany(offset, offsetLimit);
-            offset += limit;
-            offsetLimit += limit;
-            if (offsetLimit >= deviceDocuments.length) {
-                done = true;
-                await writeMany(offset, deviceDocuments.length);
-            }
-        }
-        return results;
-    }
 }
 exports.DeviceService = DeviceService;
 //# sourceMappingURL=DeviceService.js.map

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

@@ -1,43 +1,56 @@
-import { KuzzleRequest, EmbeddedSDK, Plugin } from 'kuzzle';
+import { KuzzleRequest } from 'kuzzle';
 import { Decoder } from './Decoder';
-import { BatchWriter } from './BatchProcessing';
-export declare type PayloadHandler = (request: KuzzleRequest, decoder: Decoder) => Promise<any>;
+import { DeviceContent } from '../types';
+import { MeasuresRegister } from './registers/MeasuresRegister';
+import { DeviceManagerPlugin } from '../DeviceManagerPlugin';
 export declare class PayloadService {
     private config;
     private context;
-    private batchController;
-    get sdk(): EmbeddedSDK;
-    constructor(plugin: Plugin, batchWriter: BatchWriter);
+    private measuresRegister;
+    private batch;
+    private get sdk();
+    private get app();
+    constructor(plugin: DeviceManagerPlugin, measuresRegister: MeasuresRegister);
     process(request: KuzzleRequest, decoder: Decoder, { refresh }?: {
         refresh?: any;
-    }): Promise<any>;
+    }): Promise<{
+        asset: any;
+        device: {
+            _id: string;
+            _source: DeviceContent;
+        };
+        engineId: string;
+    } | {
+        valid: boolean;
+    }>;
+    private provisionning;
+    /**
+     * Register a new device by creating the document in admin index
+     * @todo add before/afterRegister events
+     */
     private register;
     /**
-     * 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.
+     * Updates the device with the new measures:
+     *  - in admin index
+     *  - in engine index
+     *  - in linked asset
+     *  - historize measures in engine index
      *
-     * 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
+     * @todo add before/afterUpdate events
      */
-    private deviceProvisionning;
+    private update;
     /**
-     * Get the device entry from the provisioning catalog in corresponding index
+     * Updates a device with the new measures
+     *
+     * @returns Updated device
      */
-    private getCatalogEntry;
-    private update;
+    private updateDevice;
     /**
-     * Propagate the measures inside the asset document.
+     * Save measures in engine "measures" collection
      */
-    private propagateToAsset;
+    private historizeMeasures;
     /**
-     * Creates an history entry for an asset
+     * Propagate the measures inside the linked asset document.
      */
-    private historizeAsset;
+    private propagateToAsset;
 }