kuzzle-device-manager 0.4.8 → 0.4.12

package/lib/core-classes/PayloadService.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayloadService = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const kuzzle_1 = require("kuzzle");
+const uuid_1 = require("uuid");
+const models_1 = require("../models");
+const utils_1 = require("../utils");
+class PayloadService {
+    constructor(plugin, batchWriter) {
+        this.config = plugin.config;
+        this.context = plugin.context;
+        this.batchController = batchWriter.document;
+    }
+    get sdk() {
+        return this.context.accessors.sdk;
+    }
+    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 uuid = request.input.args.uuid || (0, uuid_1.v4)();
+        let valid = true;
+        try {
+            valid = await decoder.validate(payload, request);
+            if (!valid) {
+                return { valid };
+            }
+            await decoder.beforeProcessing(payload, request);
+        }
+        catch (error) {
+            valid = false;
+            throw error;
+        }
+        finally {
+            await this.batchController.create(this.config.adminIndex, 'payloads', {
+                deviceModel: decoder.deviceModel,
+                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;
+            }
+        }
+        if (!deviceContent.model) {
+            deviceContent.model = decoder.deviceModel;
+        }
+        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 });
+        }
+        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);
+    }
+    /**
+     * 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
+     */
+    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;
+    }
+    /**
+     * Get the device entry from the provisioning catalog in corresponding index
+     */
+    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 }) {
+        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);
+        refreshableCollections.push([this.config.adminIndex, 'devices']);
+        const tenantId = previousDevice._source.tenantId;
+        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']);
+            // Propagate measures into linked asset
+            const assetId = previousDevice._source.assetId;
+            if (assetId) {
+                updatedAsset = await this.propagateToAsset(tenantId, decoder, updatedDevice, assetId);
+                await this.historizeAsset(tenantId, updatedAsset);
+                refreshableCollections.push([tenantId, 'assets']);
+            }
+        }
+        if (refresh === 'wait_for') {
+            await Promise.all(refreshableCollections.map(([index, collection]) => (this.sdk.collection.refresh(index, collection))));
+        }
+        return decoder.afterUpdate(updatedDevice, updatedAsset, request);
+    }
+    /**
+     * Propagate the measures inside the asset document.
+     */
+    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);
+    }
+    /**
+     * Creates an history entry for an asset
+     */
+    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']),
+        });
+    }
+}
+exports.PayloadService = PayloadService;
+//# sourceMappingURL=PayloadService.js.map

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

@@ -0,0 +1,8 @@
+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';

package/lib/core-classes/index.js

@@ -0,0 +1,21 @@
+"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("./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);
+//# sourceMappingURL=index.js.map

package/lib/models/BaseAsset.d.ts

@@ -0,0 +1,56 @@
+import { JSONObject } from 'kuzzle';
+import { BaseAssetContent } from '../types';
+export declare class BaseAsset {
+    _id: string;
+    _source: BaseAssetContent;
+    constructor(content: BaseAssetContent, _id?: string);
+    serialize(): JSONObject;
+}
+export declare const assetsMappings: {
+    dynamic: string;
+    properties: {
+        type: {
+            type: string;
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+        };
+        model: {
+            type: string;
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+        };
+        reference: {
+            type: string;
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+        };
+        measures: {
+            properties: {};
+        };
+        metadata: {
+            dynamic: string;
+            properties: {};
+        };
+    };
+};
+export declare const assetsHistoryMappings: {
+    dynamic: string;
+    properties: {
+        assetId: {
+            type: string;
+        };
+        measureTypes: {
+            type: string;
+        };
+        asset: any;
+    };
+};

package/lib/models/BaseAsset.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assetsHistoryMappings = exports.assetsMappings = exports.BaseAsset = void 0;
+class BaseAsset {
+    constructor(content, _id) {
+        this._id = _id || `${content.type}-${content.model}-${content.reference}`;
+        this._source = content;
+    }
+    serialize() {
+        return {
+            _id: this._id,
+            _source: this._source
+        };
+    }
+}
+exports.BaseAsset = BaseAsset;
+exports.assetsMappings = {
+    dynamic: 'strict',
+    properties: {
+        type: {
+            type: 'keyword',
+            fields: {
+                text: { type: 'text' }
+            }
+        },
+        model: {
+            type: 'keyword',
+            fields: {
+                text: { type: 'text' }
+            }
+        },
+        reference: {
+            type: 'keyword',
+            fields: {
+                text: { type: 'text' }
+            }
+        },
+        measures: {
+            properties: {
+            // autogenerated from devices mappings
+            }
+        },
+        metadata: {
+            dynamic: 'false',
+            properties: {}
+        }
+    }
+};
+exports.assetsHistoryMappings = {
+    dynamic: 'strict',
+    properties: {
+        assetId: { type: 'keyword' },
+        measureTypes: { type: 'keyword' },
+        // Will be replaced by the custom asset mappings
+        asset: null,
+    }
+};
+//# sourceMappingURL=BaseAsset.js.map

package/lib/models/Catalog.d.ts

@@ -0,0 +1,55 @@
+import { JSONObject } from 'kuzzle';
+import { ConfigDocument } from './Config';
+export declare const catalogMappings: {
+    dynamic: string;
+    properties: {
+        deviceId: {
+            type: string;
+        };
+        authorized: {
+            type: string;
+        };
+        tenantId: {
+            type: string;
+        };
+        assetId: {
+            type: string;
+        };
+    };
+};
+/**
+ * Provisioning catalog entry
+ */
+export declare type CatalogContent = {
+    /**
+     * ID of the device
+     * (e.g. "Abeeway-123456")
+     */
+    deviceId: string;
+    /**
+     * If set to false, the device cannot register
+     */
+    authorized: boolean;
+    /**
+     * If set, the device will be attached to this tenant
+     */
+    tenantId?: string;
+    /**
+     * If set, the device will be linked to this asset
+     */
+    assetId?: string;
+};
+/**
+ * Catalog configuration document
+ */
+export declare class Catalog extends ConfigDocument<CatalogContent> {
+    /**
+     * Can be build either:
+     *   - with a raw config document (_id and _source properties)
+     *   - with a rule definition
+     */
+    constructor(document: CatalogContent | {
+        _id: string;
+        _source: JSONObject;
+    });
+}

package/lib/models/Catalog.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Catalog = exports.catalogMappings = void 0;
+const Config_1 = require("./Config");
+exports.catalogMappings = {
+    dynamic: 'strict',
+    properties: {
+        deviceId: { type: 'keyword' },
+        authorized: { type: 'boolean' },
+        tenantId: { type: 'keyword' },
+        assetId: { type: 'keyword' },
+    },
+};
+/**
+ * Catalog configuration document
+ */
+class Catalog extends Config_1.ConfigDocument {
+    /**
+     * Can be build either:
+     *   - with a raw config document (_id and _source properties)
+     *   - with a rule definition
+     */
+    constructor(document) {
+        if (document['_id'] || document['_source']) {
+            super(document);
+        }
+        else {
+            super({
+                _source: {
+                    type: 'catalog',
+                    catalog: document
+                }
+            });
+        }
+    }
+}
+exports.Catalog = Catalog;
+//# sourceMappingURL=Catalog.js.map

package/lib/models/Config.d.ts

@@ -0,0 +1,33 @@
+import { JSONObject } from 'kuzzle';
+import { CatalogContent } from './Catalog';
+/**
+ * Represents either a Rule or Workflow raw configuration document
+ */
+export declare type ConfigContent = ConfigCatalogContent | JSONObject;
+/**
+ * Content of a configuration document for a catalog entry
+ */
+export declare type ConfigCatalogContent = {
+    type: 'catalog';
+    catalog: CatalogContent;
+    _kuzzle_info?: JSONObject;
+};
+/**
+ * Class to manipulate configuration documents
+ */
+export declare class ConfigDocument<TConfigContent> {
+    _id: string;
+    _source: ConfigContent;
+    /**
+     * Rule or workflow definition
+     */
+    get content(): TConfigContent;
+    /**
+     * Author or updater of the document (from Kuzzle Metadata)
+     */
+    get author(): string;
+    constructor(document: {
+        _id?: string;
+        _source: JSONObject;
+    });
+}

package/lib/models/Config.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigDocument = void 0;
+/**
+ * Class to manipulate configuration documents
+ */
+class ConfigDocument {
+    constructor(document) {
+        this._id = document._id;
+        this._source = document._source;
+    }
+    /**
+     * Rule or workflow definition
+     */
+    get content() {
+        return this._source[this._source.type];
+    }
+    /**
+     * Author or updater of the document (from Kuzzle Metadata)
+     */
+    get author() {
+        return this._source._kuzzle_info.updater || this._source._kuzzle_info.author;
+    }
+}
+exports.ConfigDocument = ConfigDocument;
+//# sourceMappingURL=Config.js.map

package/lib/models/Device.d.ts

@@ -0,0 +1,102 @@
+import { JSONObject } from 'kuzzle';
+import { DeviceContent } from '../types';
+export declare class Device {
+    _id: string;
+    _source: DeviceContent;
+    constructor(content: DeviceContent, _id?: string);
+    serialize(): JSONObject;
+}
+export declare const devicesMappings: {
+    dynamic: string;
+    properties: {
+        reference: {
+            type: string;
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+        };
+        model: {
+            type: string;
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+        };
+        measures: {
+            properties: {
+                temperature: {
+                    properties: {
+                        updatedAt: {
+                            type: string;
+                        };
+                        payloadUuid: {
+                            type: string;
+                        };
+                        degree: {
+                            type: string;
+                        };
+                    };
+                };
+                position: {
+                    properties: {
+                        updatedAt: {
+                            type: string;
+                        };
+                        payloadUuid: {
+                            type: string;
+                        };
+                        point: {
+                            type: string;
+                        };
+                        altitude: {
+                            type: string;
+                        };
+                        accuracy: {
+                            type: string;
+                        };
+                    };
+                };
+                movement: {
+                    properties: {
+                        updatedAt: {
+                            type: string;
+                        };
+                        payloadUuid: {
+                            type: string;
+                        };
+                        moving: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+        };
+        qos: {
+            dynamic: string;
+            properties: {};
+        };
+        metadata: {
+            dynamic: string;
+            properties: {};
+        };
+        assetId: {
+            type: string;
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+        };
+        tenantId: {
+            type: string;
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+        };
+    };
+};

package/lib/models/Device.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devicesMappings = exports.Device = void 0;
+class Device {
+    constructor(content, _id) {
+        this._id = _id || `${content.model}-${content.reference}`;
+        this._source = {
+            qos: {},
+            metadata: {},
+            ...content
+        };
+    }
+    serialize() {
+        return {
+            _id: this._id,
+            _source: this._source
+        };
+    }
+}
+exports.Device = Device;
+exports.devicesMappings = {
+    dynamic: 'strict',
+    properties: {
+        reference: {
+            type: 'keyword',
+            fields: {
+                text: { type: 'text' }
+            }
+        },
+        model: {
+            type: 'keyword',
+            fields: {
+                text: { type: 'text' }
+            }
+        },
+        measures: {
+            properties: {
+                temperature: {
+                    properties: {
+                        // common
+                        updatedAt: { type: 'date' },
+                        payloadUuid: { type: 'keyword' },
+                        // temperature
+                        degree: { type: 'float' }
+                    }
+                },
+                position: {
+                    properties: {
+                        // common
+                        updatedAt: { type: 'date' },
+                        payloadUuid: { type: 'keyword' },
+                        // position
+                        point: { type: 'geo_point' },
+                        altitude: { type: 'float' },
+                        accuracy: { type: 'integer' },
+                    }
+                },
+                movement: {
+                    properties: {
+                        // common
+                        updatedAt: { type: 'date' },
+                        payloadUuid: { type: 'keyword' },
+                        // movement state
+                        moving: { type: 'boolean' },
+                    }
+                }
+            }
+        },
+        qos: {
+            dynamic: 'false',
+            properties: {},
+        },
+        metadata: {
+            dynamic: 'false',
+            properties: {},
+        },
+        assetId: {
+            type: 'keyword',
+            fields: {
+                text: { type: 'text' }
+            }
+        },
+        tenantId: {
+            type: 'keyword',
+            fields: {
+                text: { type: 'text' }
+            }
+        }
+    }
+};
+//# sourceMappingURL=Device.js.map

package/lib/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Device';
+export * from './BaseAsset';
+export * from './Catalog';