kuzzle-device-manager 0.4.8 → 0.4.9

package/lib/controllers/DeviceController.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceController = void 0;
+const csvtojson_1 = __importDefault(require("csvtojson"));
+const kuzzle_1 = require("kuzzle");
+const CRUDController_1 = require("./CRUDController");
+const models_1 = require("../models");
+class DeviceController extends CRUDController_1.CRUDController {
+    constructor(plugin, deviceService) {
+        super(plugin, 'devices');
+        this.deviceService = deviceService;
+        this.definition = {
+            actions: {
+                update: {
+                    handler: this.update.bind(this),
+                    http: [{ verb: 'put', path: 'device-manager/:index/devices/:_id' }]
+                },
+                search: {
+                    handler: this.search.bind(this),
+                    http: [
+                        { verb: 'post', path: 'device-manager/:index/devices/_search' },
+                        { verb: 'get', path: 'device-manager/:index/devices/_search' }
+                    ]
+                },
+                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' }]
+                },
+                linkAsset: {
+                    handler: this.linkAsset.bind(this),
+                    http: [{ verb: 'put', path: 'device-manager/:index/devices/:_id/_link/:assetId' }]
+                },
+                mLink: {
+                    handler: this.mLink.bind(this),
+                    http: [{ verb: 'put', path: 'device-manager/devices/_mLink' }]
+                },
+                unlink: {
+                    handler: this.unlink.bind(this),
+                    http: [{ verb: 'delete', path: 'device-manager/:index/devices/:_id/_unlink' }]
+                },
+                mUnlink: {
+                    handler: this.mUnlink.bind(this),
+                    http: [{ verb: 'put', path: 'device-manager/devices/_mUnlink' }]
+                },
+                prunePayloads: {
+                    handler: this.prunePayloads.bind(this),
+                    http: [{ verb: 'delete', path: 'device-manager/devices/_prunePayloads' }]
+                },
+            }
+        };
+    }
+    get sdk() {
+        return this.context.accessors.sdk;
+    }
+    /**
+     * Attach a device to a tenant
+     */
+    async attachTenant(request) {
+        const tenantId = request.getIndex();
+        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 }
+        });
+    }
+    /**
+     * 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 }
+        });
+    }
+    /**
+     * Unattach a device from it's tenant
+     */
+    async detach(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 }
+        });
+    }
+    /**
+     * 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 }
+        });
+    }
+    /**
+     * Link a device to an asset.
+     * @todo there is not 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 }
+        });
+    }
+    /**
+     * 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 }
+        });
+    }
+    /**
+     * Unlink a device from an asset.
+     */
+    async unlink(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 }
+        });
+    }
+    /**
+     * 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 }
+        });
+    }
+    /**
+     * Clean payload collection for a time period
+     */
+    async prunePayloads(request) {
+        const body = request.getBody();
+        const date = new Date().setDate(new Date().getDate() - body.days || 7);
+        const filter = [];
+        filter.push({
+            range: {
+                '_kuzzle_info.createdAt': {
+                    lt: date
+                }
+            }
+        });
+        if (body.deviceModel) {
+            filter.push({ term: { deviceModel: body.deviceModel } });
+        }
+        if (body.keepInvalid) {
+            filter.push({ term: { valid: true } });
+        }
+        return await 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 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,
+                deviceId,
+                assetId
+            }));
+        }
+        else if (body.records) {
+            bulkData = body.records;
+        }
+        else if (body.deviceIds) {
+            bulkData = body.deviceIds.map((deviceId) => ({ deviceId }));
+        }
+        else {
+            throw new kuzzle_1.BadRequestError(`Malformed request missing property csv, records, deviceIds`);
+        }
+        const strict = request.getBoolean('strict');
+        return { strict, bulkData };
+    }
+}
+exports.DeviceController = DeviceController;
+//# sourceMappingURL=DeviceController.js.map

package/lib/controllers/index.d.ts

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

package/lib/controllers/index.js

@@ -0,0 +1,16 @@
+"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]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AssetController"), exports);
+__exportStar(require("./CRUDController"), exports);
+__exportStar(require("./DeviceController"), exports);
+//# sourceMappingURL=index.js.map

package/lib/core-classes/BatchProcessing/BatchController.d.ts

@@ -0,0 +1,32 @@
+import { DocumentController, EmbeddedSDK, JSONObject } from 'kuzzle';
+import { BatchWriter } from './BatchWriter';
+/**
+ * Overload of the document controller.
+ *
+ * This class replace the following methods and will execute them by batch using
+ * m* actions:
+ *  - create
+ *  - replace
+ *  - createOrReplace
+ *  - update
+ *  - get
+ *  - exists
+ *  - delete
+ *
+ * The m* actions returns the successes in the same order as in the request so
+ * since we have the index of the single document inside the array of documents
+ * sent to the action, we can retrieve the corresponding result in the array of
+ * results.
+ *
+ */
+export declare class BatchController extends DocumentController {
+    writer: BatchWriter;
+    constructor(sdk: EmbeddedSDK, writer: BatchWriter);
+    create(index: string, collection: string, content: JSONObject, _id?: string, options?: JSONObject): Promise<any>;
+    replace(index: string, collection: string, _id: string, content: JSONObject, options?: JSONObject): Promise<any>;
+    createOrReplace(index: string, collection: string, _id: string, content: JSONObject, options?: JSONObject): Promise<any>;
+    update(index: string, collection: string, _id: string, changes: JSONObject, options?: JSONObject): Promise<any>;
+    get(index: string, collection: string, id: string): Promise<any>;
+    exists(index: string, collection: string, id: string): Promise<any>;
+    delete(index: string, collection: string, id: string): Promise<any>;
+}

package/lib/core-classes/BatchProcessing/BatchController.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchController = void 0;
+const kuzzle_1 = require("kuzzle");
+/**
+ * Overload of the document controller.
+ *
+ * This class replace the following methods and will execute them by batch using
+ * m* actions:
+ *  - create
+ *  - replace
+ *  - createOrReplace
+ *  - update
+ *  - get
+ *  - exists
+ *  - delete
+ *
+ * The m* actions returns the successes in the same order as in the request so
+ * since we have the index of the single document inside the array of documents
+ * sent to the action, we can retrieve the corresponding result in the array of
+ * results.
+ *
+ */
+class BatchController extends kuzzle_1.DocumentController {
+    constructor(sdk, writer) {
+        super(sdk);
+        this.writer = writer;
+    }
+    async create(index, collection, content, _id, options) {
+        const { idx, promise } = this.writer.addCreate(index, collection, content, _id, options);
+        const { successes } = await promise.promise;
+        return successes[idx];
+    }
+    async replace(index, collection, _id, content, options) {
+        const { idx, promise } = this.writer.addReplace(index, collection, content, _id, options);
+        const { successes, errors } = await promise.promise;
+        const error = errors.find(({ _id: id }) => id === _id);
+        if (error) {
+            throw new kuzzle_1.BadRequestError(`Cannot replace document "${_id}": ${error}`);
+        }
+        return successes[idx];
+    }
+    async createOrReplace(index, collection, _id, content, options) {
+        const { idx, promise } = this.writer.addCreateOrReplace(index, collection, content, _id, options);
+        const { successes, errors } = await promise.promise;
+        const error = errors.find(({ document }) => document._id === _id);
+        if (error) {
+            throw new kuzzle_1.BadRequestError(`Cannot create or replace document "${_id}": ${error}`);
+        }
+        return successes[idx];
+    }
+    async update(index, collection, _id, changes, options) {
+        const { idx, promise } = this.writer.addUpdate(index, collection, changes, _id, options);
+        const { successes, errors } = await promise.promise;
+        const error = errors.find(({ _id: id }) => id === _id);
+        if (error) {
+            throw new kuzzle_1.BadRequestError(`Cannot update document "${_id}": ${error}`);
+        }
+        return successes[idx];
+    }
+    async get(index, collection, id) {
+        const { promise } = this.writer.addGet(index, collection, undefined, id);
+        const { successes } = await promise.promise;
+        const document = successes.find(({ _id }) => _id === id);
+        if (!document) {
+            throw new kuzzle_1.NotFoundError(`Document ${id} not found`, 'services.storage.not_found');
+        }
+        return document;
+    }
+    async exists(index, collection, id) {
+        const { idx, promise } = this.writer.addExists(index, collection, undefined, id);
+        const { successes } = await promise.promise;
+        return successes[idx];
+    }
+    async delete(index, collection, id) {
+        const { idx, promise } = this.writer.addDelete(index, collection, undefined, id);
+        const { successes, errors } = await promise.promise;
+        const error = errors.find(({ _id }) => _id === id);
+        if (error) {
+            throw new kuzzle_1.NotFoundError(`Cannot delete document ${id}: ${error}`);
+        }
+        return successes[idx];
+    }
+}
+exports.BatchController = BatchController;
+//# sourceMappingURL=BatchController.js.map

package/lib/core-classes/BatchProcessing/BatchWriter.d.ts

@@ -0,0 +1,110 @@
+import { EmbeddedSDK, JSONObject } from 'kuzzle';
+import { BatchController } from './BatchController';
+import { InstrumentablePromise } from './InstrumentablePromise';
+/**
+ * Map of index and collections with documents, options and associated promise
+ */
+declare type IndexBuffer = {
+    [index: string]: {
+        [collection: string]: {
+            documents: Array<{
+                _id: string;
+                body: JSONObject;
+            }>;
+            promise: InstrumentablePromise;
+            options: JSONObject;
+        };
+    };
+};
+export declare class BatchBuffer {
+    indexes: IndexBuffer;
+    /**
+     * Add a document to the buffer of a specific collection
+     *
+     * @param index Index name
+     * @param collection Collection name
+     * @param body Document content
+     * @param _id Document ID
+     * @param options Option object passed to the m* action
+     *
+     * @returns An object containing the index of the array of results and a promise resolving to the array of results
+     */
+    add(index: string, collection: string, body: JSONObject, _id?: string, options?: JSONObject): {
+        idx: number;
+        promise: InstrumentablePromise;
+    };
+}
+/**
+ * This class handle buffers for every supported API action of the document controller:
+ *  - create, update, createOrReplace, replace, get, exists, delete
+ *
+ * Each buffer is filled with documents to be write/get/delete into a collection.
+ *
+ * A timer will regularly execute the m* actions with the documents inside the buffers.
+ *
+ * If the interval is too big, buffers may contain too much documents for Kuzzle limits.
+ * (e.g. "limits.documentsWriteCount" is 200 by default)
+ */
+export declare class BatchWriter {
+    private timer;
+    private sdk;
+    /**
+     * Timer interval to execute m* API actions
+     */
+    private interval;
+    /**
+     * Max write buffer size. (Should match "limits.documentsWriteCount")
+     */
+    private maxWriteBufferSize;
+    /**
+     * Max read buffer size. (Should match "limits.documentsReadCount")
+     */
+    private maxReadBufferSize;
+    private buffers;
+    /**
+     * Document Controller overload
+     */
+    document: BatchController;
+    get addCreate(): any;
+    get addUpdate(): any;
+    get addGet(): any;
+    get addExists(): any;
+    get addDelete(): any;
+    get addReplace(): any;
+    get addCreateOrReplace(): any;
+    /**
+     * @param sdk Connected SDK
+     * @param options.interval Timer interval in ms (50). Actions will be executed every {interval} ms
+     * @param options.maxWriteBufferSize Max write buffer size (200). (Should match "limits.documentsWriteCount")
+     * @param options.maxReadBufferSize Max read buffer size. (Should match "limits.documentsReadCount")
+     */
+    constructor(sdk: EmbeddedSDK, { interval, maxWriteBufferSize, maxReadBufferSize }?: {
+        interval?: number;
+        maxWriteBufferSize?: number;
+        maxReadBufferSize?: number;
+    });
+    /**
+     * Execute API actions with documents stored in the buffers.
+     */
+    execute(): Promise<void>;
+    /**
+     * Initialize the buffers and start the timer
+     */
+    begin(): void;
+    /**
+     * Execute pending actions from the buffers and stop the timer.
+     */
+    end(): Promise<void>;
+    /**
+     * Reset all the buffers
+     */
+    private prepareRound;
+    private sendCreateBuffer;
+    private sendUpdateBuffer;
+    private sendReplaceBuffer;
+    private sendCreateOrReplaceBuffer;
+    private sendGetBuffer;
+    private sendExistsBuffer;
+    private sendDeleteBuffer;
+}
+export {};