kuzzle-device-manager 0.4.13 → 2.0.0-rc3

package/lib/controllers/DecodersController.d.ts

@@ -0,0 +1,16 @@
+import { ControllerDefinition } from 'kuzzle';
+import { DeviceManagerPlugin } from '../DeviceManagerPlugin';
+import { DecodersRegister } from '../core-classes';
+export declare class DecodersController {
+    private context;
+    private config;
+    private decodersRegister;
+    definition: ControllerDefinition;
+    constructor(plugin: DeviceManagerPlugin, decodersRegister: DecodersRegister);
+    /**
+     * List all available decoders
+     */
+    list(): Promise<{
+        decoders: import("../types").DecoderContent[];
+    }>;
+}

package/lib/controllers/DecodersController.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecodersController = void 0;
+class DecodersController {
+    constructor(plugin, decodersRegister) {
+        this.context = plugin.context;
+        this.config = plugin.config;
+        this.decodersRegister = decodersRegister;
+        this.definition = {
+            actions: {
+                list: {
+                    handler: this.list.bind(this),
+                    http: [{ path: 'device-manager/decoders', verb: 'get' }],
+                }
+            }
+        };
+    }
+    /**
+     * List all available decoders
+     */
+    async list() {
+        const decoders = await this.decodersRegister.list();
+        return { decoders };
+    }
+}
+exports.DecodersController = DecodersController;
+//# sourceMappingURL=DecodersController.js.map

package/lib/controllers/DeviceController.d.ts

@@ -1,56 +1,59 @@
-import { KuzzleRequest, EmbeddedSDK, Plugin } from 'kuzzle';
-import { CRUDController } from './CRUDController';
+import { CRUDController } from 'kuzzle-plugin-commons';
+import { KuzzleRequest } from 'kuzzle';
 import { DeviceService } from '../core-classes';
+import { DeviceManagerPlugin } from '../DeviceManagerPlugin';
+import { DeviceContent, DeviceManagerConfiguration } from '../types';
 export declare class DeviceController extends CRUDController {
+    protected config: DeviceManagerConfiguration;
     private deviceService;
-    get sdk(): EmbeddedSDK;
-    constructor(plugin: Plugin, deviceService: DeviceService);
+    constructor(plugin: DeviceManagerPlugin, deviceService: DeviceService);
+    /**
+     * Create and provision a new device
+     */
+    create(request: KuzzleRequest): Promise<import("kuzzle").KDocument<DeviceContent>>;
+    update(): Promise<any>;
+    search(): Promise<void>;
+    delete(): Promise<any>;
     /**
      * Attach a device to a tenant
      */
-    attachTenant(request: KuzzleRequest): Promise<void>;
+    attachEngine(request: KuzzleRequest): Promise<void>;
     /**
      * Attach multiple devices to multiple tenants
      */
-    mAttach(request: KuzzleRequest): Promise<import("../types").DeviceMAttachementContent>;
+    mAttachEngines(request: KuzzleRequest): Promise<any[]>;
     /**
      * Unattach a device from it's tenant
      */
-    detach(request: KuzzleRequest): Promise<void>;
+    detachEngine(request: KuzzleRequest): Promise<void>;
     /**
      * Detach multiple devices from multiple tenants
      */
-    mDetach(request: KuzzleRequest): Promise<{
-        errors: any[];
-        successes: any[];
-    }>;
+    mDetachEngines(request: KuzzleRequest): Promise<any[]>;
     /**
      * Link a device to an asset.
-     * @todo there is not restriction according to tenant index?
+     * @todo there is no restriction according to tenant index?
      */
     linkAsset(request: KuzzleRequest): Promise<void>;
     /**
      * Link multiple devices to multiple assets.
      */
-    mLink(request: KuzzleRequest): Promise<{
-        errors: any[];
-        successes: any[];
-    }>;
+    mLinkAssets(request: KuzzleRequest): Promise<void>;
     /**
      * Unlink a device from an asset.
      */
-    unlink(request: KuzzleRequest): Promise<void>;
+    unlinkAsset(request: KuzzleRequest): Promise<void>;
     /**
      * Unlink multiple device from multiple assets.
      */
-    mUnlink(request: KuzzleRequest): Promise<{
-        errors: any[];
-        successes: any[];
-    }>;
+    mUnlinkAssets(request: KuzzleRequest): Promise<void>;
     /**
      * Clean payload collection for a time period
      */
     prunePayloads(request: KuzzleRequest): Promise<any>;
-    private mGetDevice;
+    importDevices(request: KuzzleRequest): Promise<{
+        errors: any[];
+        successes: any[];
+    }>;
     private mParseRequest;
 }

package/lib/controllers/DeviceController.js

@@ -5,162 +5,200 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceController = void 0;
 const csvtojson_1 = __importDefault(require("csvtojson"));
+const kuzzle_plugin_commons_1 = require("kuzzle-plugin-commons");
 const kuzzle_1 = require("kuzzle");
-const CRUDController_1 = require("./CRUDController");
-const models_1 = require("../models");
-class DeviceController extends CRUDController_1.CRUDController {
+class DeviceController extends kuzzle_plugin_commons_1.CRUDController {
     constructor(plugin, deviceService) {
         super(plugin, 'devices');
         this.deviceService = deviceService;
+        /* eslint-disable sort-keys */
         this.definition = {
             actions: {
-                update: {
-                    handler: this.update.bind(this),
-                    http: [{ verb: 'put', path: 'device-manager/:index/devices/:_id' }]
+                attachEngine: {
+                    handler: this.attachEngine.bind(this),
+                    http: [{ path: 'device-manager/:index/devices/:_id/_attach', verb: 'put' }]
                 },
-                search: {
-                    handler: this.search.bind(this),
-                    http: [
-                        { verb: 'post', path: 'device-manager/:index/devices/_search' },
-                        { verb: 'get', path: 'device-manager/:index/devices/_search' }
-                    ]
+                detachEngine: {
+                    handler: this.detachEngine.bind(this),
+                    http: [{ path: 'device-manager/devices/:_id/_detach', verb: 'delete' }]
                 },
-                attachTenant: {
-                    handler: this.attachTenant.bind(this),
-                    http: [{ verb: 'put', path: 'device-manager/:index/devices/:_id/_attach' }]
-                },
-                mAttach: {
-                    handler: this.mAttach.bind(this),
-                    http: [{ verb: 'put', path: 'device-manager/devices/_mAttach' }]
-                },
-                detach: {
-                    handler: this.detach.bind(this),
-                    http: [{ verb: 'delete', path: 'device-manager/devices/:_id/_detach' }]
-                },
-                mDetach: {
-                    handler: this.mDetach.bind(this),
-                    http: [{ verb: 'put', path: 'device-manager/devices/_mDetach' }]
+                importDevices: {
+                    handler: this.importDevices.bind(this),
+                    http: [{ path: 'device-manager/devices/_import', verb: 'post' }]
                 },
                 linkAsset: {
                     handler: this.linkAsset.bind(this),
-                    http: [{ verb: 'put', path: 'device-manager/:index/devices/:_id/_link/:assetId' }]
+                    http: [{ path: 'device-manager/:index/devices/:_id/_link/:assetId', verb: 'put' }]
                 },
-                mLink: {
-                    handler: this.mLink.bind(this),
-                    http: [{ verb: 'put', path: 'device-manager/devices/_mLink' }]
+                mAttachEngines: {
+                    handler: this.mAttachEngines.bind(this),
+                    http: [{ path: 'device-manager/devices/_mAttach', verb: 'put' }]
                 },
-                unlink: {
-                    handler: this.unlink.bind(this),
-                    http: [{ verb: 'delete', path: 'device-manager/:index/devices/:_id/_unlink' }]
+                mDetachEngines: {
+                    handler: this.mDetachEngines.bind(this),
+                    http: [{ path: 'device-manager/devices/_mDetach', verb: 'put' }]
                 },
-                mUnlink: {
-                    handler: this.mUnlink.bind(this),
-                    http: [{ verb: 'put', path: 'device-manager/devices/_mUnlink' }]
+                mLinkAssets: {
+                    handler: this.mLinkAssets.bind(this),
+                    http: [{ path: 'device-manager/devices/_mLink', verb: 'put' }]
+                },
+                mUnlinkAssets: {
+                    handler: this.mUnlinkAssets.bind(this),
+                    http: [{ path: 'device-manager/devices/_mUnlink', verb: 'put' }]
                 },
                 prunePayloads: {
                     handler: this.prunePayloads.bind(this),
-                    http: [{ verb: 'delete', path: 'device-manager/devices/_prunePayloads' }]
+                    http: [{ path: 'device-manager/devices/_prunePayloads', verb: 'delete' }]
+                },
+                unlinkAsset: {
+                    handler: this.unlinkAsset.bind(this),
+                    http: [{ path: 'device-manager/:index/devices/:_id/_unlink', verb: 'delete' }]
+                },
+                // CRUD Controller
+                create: {
+                    handler: this.create.bind(this),
+                    http: [{ path: 'device-manager/:index/devices', verb: 'post' }]
                 },
             }
         };
+        /* eslint-enable sort-keys */
+    }
+    /**
+     * Create and provision a new device
+     */
+    async create(request) {
+        const engineId = request.getString('engineId');
+        const model = request.getBodyString('model');
+        const reference = request.getBodyString('reference');
+        const assetId = request.input.args.assetId || null;
+        const metadata = request.getBodyObject('metadata', {});
+        const refresh = request.getRefresh();
+        const deviceContent = {
+            measures: [],
+            metadata,
+            model,
+            reference,
+        };
+        const device = await this.deviceService.create(engineId, deviceContent, assetId, {
+            refresh
+        });
+        return device;
+    }
+    // @todo to be implemented
+    async update() {
+        throw new kuzzle_1.PluginImplementationError('Not available');
     }
-    get sdk() {
-        return this.context.accessors.sdk;
+    // @todo to be implemented
+    async search() {
+        throw new kuzzle_1.PluginImplementationError('Not available');
+    }
+    // @todo to be implemented
+    async delete() {
+        throw new kuzzle_1.PluginImplementationError('Not available');
     }
     /**
      * Attach a device to a tenant
      */
-    async attachTenant(request) {
-        const tenantId = request.getIndex();
+    async attachEngine(request) {
+        const engineId = request.getString('engineId');
         const deviceId = request.getId();
-        const document = { tenantId: tenantId, deviceId: deviceId };
-        const devices = await this.mGetDevice([document]);
-        await this.deviceService.mAttach(devices, [document], {
-            strict: true,
-            options: { ...request.input.args }
-        });
+        const refresh = request.getRefresh();
+        const strict = request.getBoolean('strict');
+        const attacheRequest = {
+            deviceId,
+            engineId,
+        };
+        await this.deviceService.attachEngine(attacheRequest, { refresh, strict });
     }
     /**
      * Attach multiple devices to multiple tenants
      */
-    async mAttach(request) {
-        const { bulkData, strict } = await this.mParseRequest(request);
-        const devices = await this.mGetDevice(bulkData);
-        return this.deviceService.mAttach(devices, bulkData, {
-            strict,
-            options: { ...request.input.args }
-        });
+    async mAttachEngines(request) {
+        const { bulkData } = await this.mParseRequest(request);
+        const refresh = request.getRefresh();
+        const strict = request.getBoolean('strict');
+        const promises = [];
+        for (const { engineId, deviceId } of bulkData) {
+            const attacheRequest = {
+                deviceId,
+                engineId,
+            };
+            promises.push(this.deviceService.attachEngine(attacheRequest, { refresh, strict }));
+        }
+        return await Promise.all(promises);
     }
     /**
      * Unattach a device from it's tenant
      */
-    async detach(request) {
+    async detachEngine(request) {
         const deviceId = request.getId();
-        const document = { deviceId };
-        const devices = await this.mGetDevice([document]);
-        await this.deviceService.mDetach(devices, [document], {
-            strict: true,
-            options: { ...request.input.args }
-        });
+        const refresh = request.getRefresh();
+        const strict = request.getBoolean('strict');
+        await this.deviceService.detachEngine(deviceId, { refresh, strict });
     }
     /**
      * Detach multiple devices from multiple tenants
      */
-    async mDetach(request) {
-        const { bulkData, strict } = await this.mParseRequest(request);
-        const devices = await this.mGetDevice(bulkData);
-        return this.deviceService.mDetach(devices, bulkData, {
-            strict,
-            options: { ...request.input.args }
-        });
+    async mDetachEngines(request) {
+        const { bulkData } = await this.mParseRequest(request);
+        const promises = [];
+        for (const { deviceId } of bulkData) {
+            promises.push(this.deviceService.detachEngine(deviceId, request.input.args));
+        }
+        return await Promise.all(promises);
     }
     /**
      * Link a device to an asset.
-     * @todo there is not restriction according to tenant index?
+     * @todo there is no restriction according to tenant index?
      */
     async linkAsset(request) {
         const assetId = request.getString('assetId');
         const deviceId = request.getId();
-        const document = { deviceId, assetId };
-        const devices = await this.mGetDevice([document]);
-        await this.deviceService.mLink(devices, [document], {
-            strict: true,
-            options: { ...request.input.args }
-        });
+        const measuresNames = request.getBodyObject('measuresNames', {});
+        const refresh = request.getRefresh();
+        const linkRequest = {
+            assetId,
+            deviceId,
+            measuresNames,
+        };
+        await this.deviceService.linkAsset(linkRequest, { refresh });
     }
     /**
      * Link multiple devices to multiple assets.
      */
-    async mLink(request) {
-        const { bulkData, strict } = await this.mParseRequest(request);
-        const devices = await this.mGetDevice(bulkData);
-        return this.deviceService.mLink(devices, bulkData, {
-            strict,
-            options: { ...request.input.args }
-        });
+    async mLinkAssets(request) {
+        const { bulkData } = await this.mParseRequest(request);
+        const refresh = request.getRefresh();
+        for (const { deviceId, assetId } of bulkData) {
+            const linkRequest = {
+                assetId,
+                deviceId,
+                // @todo handle measure names
+            };
+            // Cannot be done in parallel because we need to copy previous measures
+            await this.deviceService.linkAsset(linkRequest, { refresh });
+        }
     }
     /**
      * Unlink a device from an asset.
      */
-    async unlink(request) {
+    async unlinkAsset(request) {
         const deviceId = request.getId();
-        const document = { deviceId };
-        const devices = await this.mGetDevice([document]);
-        await this.deviceService.mUnlink(devices, {
-            strict: true,
-            options: { ...request.input.args }
-        });
+        const refresh = request.getRefresh();
+        const strict = request.getBoolean('strict');
+        await this.deviceService.unlinkAsset(deviceId, { refresh, strict });
     }
     /**
      * Unlink multiple device from multiple assets.
      */
-    async mUnlink(request) {
-        const { bulkData, strict } = await this.mParseRequest(request);
-        const devices = await this.mGetDevice(bulkData);
-        return this.deviceService.mUnlink(devices, {
-            strict,
-            options: { ...request.input.args }
-        });
+    async mUnlinkAssets(request) {
+        const { bulkData } = await this.mParseRequest(request);
+        const refresh = request.getRefresh();
+        const strict = request.getBoolean('strict');
+        for (const { deviceId } of bulkData) {
+            // Cannot be done in parallel because we need to keep previous measures
+            await this.deviceService.unlinkAsset(deviceId, { refresh, strict });
+        }
     }
     /**
      * Clean payload collection for a time period
@@ -182,23 +220,26 @@ class DeviceController extends CRUDController_1.CRUDController {
         if (body.keepInvalid) {
             filter.push({ term: { valid: true } });
         }
-        return await this.as(request.context.user).bulk.deleteByQuery(this.config.adminIndex, 'payloads', { query: { bool: { filter } } });
+        return this.as(request.context.user).bulk.deleteByQuery(this.config.adminIndex, 'payloads', { query: { bool: { filter } } });
     }
-    async mGetDevice(devices) {
-        const deviceIds = devices.map(doc => doc.deviceId);
-        const result = await this.sdk.document.mGet(this.config.adminIndex, 'devices', deviceIds);
-        return result.successes.map((document) => new models_1.Device(document._source, document._id));
+    async importDevices(request) {
+        const content = request.getBodyString('csv');
+        const refresh = request.getRefresh();
+        const devices = await (0, csvtojson_1.default)({ delimiter: 'auto' }).fromString(content);
+        return this.deviceService.importDevices(devices, {
+            refresh,
+            strict: true
+        });
     }
     async mParseRequest(request) {
         const body = request.input.body;
         let bulkData;
         if (body.csv) {
-            const lines = await (0, csvtojson_1.default)({ delimiter: 'auto' })
-                .fromString(body.csv);
-            bulkData = lines.map(({ tenantId, deviceId, assetId }) => ({
-                tenantId,
+            const lines = await (0, csvtojson_1.default)({ delimiter: 'auto' }).fromString(body.csv);
+            bulkData = lines.map(({ engineId, deviceId, assetId }) => ({
+                assetId,
                 deviceId,
-                assetId
+                engineId
             }));
         }
         else if (body.records) {
@@ -208,10 +249,10 @@ class DeviceController extends CRUDController_1.CRUDController {
             bulkData = body.deviceIds.map((deviceId) => ({ deviceId }));
         }
         else {
-            throw new kuzzle_1.BadRequestError(`Malformed request missing property csv, records, deviceIds`);
+            throw new kuzzle_1.BadRequestError('Malformed request missing property csv, records, deviceIds');
         }
         const strict = request.getBoolean('strict');
-        return { strict, bulkData };
+        return { bulkData, strict };
     }
 }
 exports.DeviceController = DeviceController;

package/lib/controllers/index.d.ts

@@ -1,3 +1,3 @@
 export * from './AssetController';
-export * from './CRUDController';
 export * from './DeviceController';
+export * from './DecodersController';

package/lib/controllers/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];
@@ -11,6 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./AssetController"), exports);
-__exportStar(require("./CRUDController"), exports);
 __exportStar(require("./DeviceController"), exports);
+__exportStar(require("./DecodersController"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,31 @@
+import { Plugin, JSONObject, KDocument } from 'kuzzle';
+import { MeasureContent } from '../types';
+export declare class AssetService {
+    private config;
+    private context;
+    private get sdk();
+    constructor(plugin: Plugin);
+    /**
+     * Returns measures history for an asset
+     *
+     * @param engineId Engine ID
+     * @param assetId Asset ID
+     * @param options.size Number of measures to return
+     * @param options.startAt Returns measures starting from this date (ISO8601)
+     * @param options.endAt Returns measures until this date (ISO8601)
+     */
+    measureHistory(engineId: string, assetId: string, { size, startAt, endAt }: {
+        size?: number;
+        startAt?: string;
+        endAt?: string;
+    }): Promise<KDocument<MeasureContent>[]>;
+    importAssets(index: string, assets: JSONObject, { strict, options }: {
+        strict?: boolean;
+        options?: JSONObject;
+    }): Promise<{
+        errors: any[];
+        successes: any[];
+    }>;
+    private getAsset;
+    private iso8601;
+}

package/lib/core-classes/AssetService.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetService = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const kuzzle_1 = require("kuzzle");
+const writeMany_1 = require("../utils/writeMany");
+const BaseAsset_1 = require("../models/BaseAsset");
+class AssetService {
+    constructor(plugin) {
+        this.config = plugin.config;
+        this.context = plugin.context;
+    }
+    get sdk() {
+        return this.context.accessors.sdk;
+    }
+    /**
+     * Returns measures history for an asset
+     *
+     * @param engineId Engine ID
+     * @param assetId Asset ID
+     * @param options.size Number of measures to return
+     * @param options.startAt Returns measures starting from this date (ISO8601)
+     * @param options.endAt Returns measures until this date (ISO8601)
+     */
+    async measureHistory(engineId, assetId, { size = 25, startAt, endAt }) {
+        await this.getAsset(engineId, assetId);
+        const query = {
+            range: {
+                measuredAt: {
+                    gte: 0,
+                    lte: Number.MAX_SAFE_INTEGER,
+                }
+            }
+        };
+        if (startAt) {
+            query.range.measuredAt.gte = this.iso8601(startAt, 'startAt').getTime();
+        }
+        if (endAt) {
+            query.range.measuredAt.lte = this.iso8601(startAt, 'endAt').getTime();
+        }
+        const sort = { 'measuredAt': 'desc' };
+        const measures = await this.sdk.document.search(engineId, 'measures', { query, sort }, { size: size || 25 });
+        return measures.hits;
+    }
+    async importAssets(index, assets, { strict, options }) {
+        const results = {
+            errors: [],
+            successes: [],
+        };
+        const assetDocuments = assets.map((asset) => {
+            const _asset = new BaseAsset_1.BaseAsset(asset);
+            return {
+                _id: _asset._id,
+                body: lodash_1.default.omit(asset, ['_id']),
+            };
+        });
+        await (0, writeMany_1.writeToDatabase)(assetDocuments, async (result) => {
+            const created = await this.sdk.document.mCreate(index, 'assets', result, { strict, ...options });
+            return {
+                errors: results.errors.concat(created.errors),
+                successes: results.successes.concat(created.successes),
+            };
+        });
+        return results;
+    }
+    getAsset(engineId, assetId) {
+        return this.sdk.document.get(engineId, 'assets', assetId);
+    }
+    // @todo remove when we have the date extractor in the core
+    iso8601(value, name) {
+        const parsed = new Date(value);
+        if (isNaN(parsed)) {
+            throw new kuzzle_1.BadRequestError(`"${name}" is not a valid ISO8601 date`);
+        }
+        return parsed;
+    }
+}
+exports.AssetService = AssetService;
+//# sourceMappingURL=AssetService.js.map