kuzzle-device-manager 2.0.0-rc1 → 2.0.0-rc3

package/lib/controllers/AssetController.d.ts

@@ -5,6 +5,9 @@ export declare class AssetController extends CRUDController {
     private assetService;
     private get sdk();
     constructor(plugin: Plugin, assetService: AssetService);
+    measures(request: KuzzleRequest): Promise<{
+        measures: import("kuzzle").KDocument<import("../types").MeasureContent>[];
+    }>;
     update(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
         [x: string]: any;
     }>>;

package/lib/controllers/AssetController.js

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetController = void 0;
 const csvtojson_1 = __importDefault(require("csvtojson"));
 const kuzzle_plugin_commons_1 = require("kuzzle-plugin-commons");
+const kuzzle_1 = require("kuzzle");
 const BaseAsset_1 = require("../models/BaseAsset");
 class AssetController extends kuzzle_plugin_commons_1.CRUDController {
     constructor(plugin, assetService) {
         super(plugin, 'assets');
         this.assetService = assetService;
+        /* eslint-disable sort-keys */
         this.definition = {
             actions: {
                 create: {
@@ -35,13 +37,30 @@ class AssetController extends kuzzle_plugin_commons_1.CRUDController {
                 update: {
                     handler: this.update.bind(this),
                     http: [{ path: 'device-manager/:index/assets/:_id', verb: 'put' }],
+                },
+                measures: {
+                    handler: this.measures.bind(this),
+                    http: [{ path: 'device-manager/:index/assets/:_id/measures', verb: 'get' }],
                 }
             },
         };
+        /* eslint-enable sort-keys */
     }
     get sdk() {
         return this.context.accessors.sdk;
     }
+    async measures(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const size = request.input.args.size;
+        const startAt = request.input.args.startAt;
+        const endAt = request.input.args.endAt;
+        if (size && startAt || size && endAt) {
+            throw new kuzzle_1.BadRequestError('You cannot specify both a "size" and a "startAt" or "endAt"');
+        }
+        const measures = await this.assetService.measureHistory(engineId, id, { endAt, size, startAt });
+        return { measures };
+    }
     async update(request) {
         const id = request.getId();
         const engineId = request.getString('engineId');

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

@@ -1,9 +1,24 @@
-import { Plugin, JSONObject } from 'kuzzle';
+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;
@@ -11,4 +26,6 @@ export declare class AssetService {
         errors: any[];
         successes: any[];
     }>;
+    private getAsset;
+    private iso8601;
 }

package/lib/core-classes/AssetService.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (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 {
@@ -15,6 +16,35 @@ class AssetService {
     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: [],
@@ -36,6 +66,17 @@ class AssetService {
         });
         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

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

@@ -45,6 +45,9 @@ export declare abstract class Decoder {
     /**
      * @param deviceModel Device model for this decoder
      * @param deviceMeasures Devices measure types for this decoder
+     *
+     * @example
+     * super('AbeewayGPS', ['position']);
      */
     constructor(deviceModel: string, deviceMeasures: string[]);
     /**
@@ -65,7 +68,6 @@ export declare abstract class Decoder {
      * Decode the payload:
      *  - set "reference"
      *  - fetch measures
-     *  - fetch qos
      *
      * @param payload Raw payload received in the API action body
      * @param request Original request

package/lib/core-classes/Decoder.js

@@ -16,6 +16,9 @@ class Decoder {
     /**
      * @param deviceModel Device model for this decoder
      * @param deviceMeasures Devices measure types for this decoder
+     *
+     * @example
+     * super('AbeewayGPS', ['position']);
      */
     constructor(deviceModel, deviceMeasures) {
         /**

package/lib/core-classes/PayloadService.js

@@ -53,10 +53,10 @@ class PayloadService {
             newMeasures.push({
                 measuredAt: measure.measuredAt,
                 origin: {
+                    assetId: null,
                     id: deviceId,
                     model: decoder.deviceModel,
                     payloadUuids: [uuid],
-                    reference: decodedPayload.reference,
                     type: 'device',
                 },
                 type,
@@ -67,6 +67,11 @@ class PayloadService {
         try {
             const deviceDoc = await this.batch.get(this.config.adminIndex, 'devices', deviceId);
             const device = new models_1.Device(deviceDoc._source);
+            if (device._source.assetId) {
+                for (const measure of newMeasures) {
+                    measure.origin.assetId = device._source.assetId;
+                }
+            }
             return await this.update(device, newMeasures, { refresh });
         }
         catch (error) {

package/lib/mappings/measuresMappings.d.ts

@@ -12,6 +12,7 @@ export declare const measuresMappings: {
             type: string;
         };
         origin: {
+            type: string;
             properties: {
                 id: {
                     type: string;
@@ -22,10 +23,10 @@ export declare const measuresMappings: {
                 payloadUuids: {
                     type: string;
                 };
-                reference: {
+                type: {
                     type: string;
                 };
-                type: {
+                assetId: {
                     type: string;
                 };
             };
@@ -42,17 +43,8 @@ export declare const measuresMappings: {
          * Measure self-description
          */
         unit: {
-            properties: {
-                name: {
-                    type: string;
-                };
-                sign: {
-                    type: string;
-                };
-                type: {
-                    type: string;
-                };
-            };
+            dynamic: string;
+            properties: {};
         };
         values: {
             properties: {};

package/lib/mappings/measuresMappings.js

@@ -1,16 +1,18 @@
 "use strict";
+/* eslint-disable sort-keys */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.measuresMappings = void 0;
 exports.measuresMappings = {
     dynamic: 'strict',
     properties: {
-        measuredAt: { type: 'float' },
+        measuredAt: { type: 'double' },
         /**
          * A device may have different measures for the same type (e.g. measure temperature 2 times)
          * Should be set when you link the device to the asset
          */
         name: { type: 'keyword' },
         origin: {
+            type: 'nested',
             properties: {
                 // ID of the device (document _id)
                 id: { type: 'keyword' },
@@ -18,10 +20,10 @@ exports.measuresMappings = {
                 model: { type: 'keyword' },
                 // Array of payload uuids that were used to create this measure.
                 payloadUuids: { type: 'keyword' },
-                // Reference of the data source (e.g. a device manufacturer ID)
-                reference: { type: 'keyword' },
                 // E.g. "device"
                 type: { type: 'keyword' },
+                // Asset linked to the device when the measure was made
+                assetId: { type: 'keyword' },
             }
         },
         /**
@@ -34,15 +36,13 @@ exports.measuresMappings = {
          * Measure self-description
          */
         unit: {
-            properties: {
-                name: { type: 'keyword' },
-                sign: { type: 'keyword' },
-                type: { type: 'keyword' },
-            }
+            dynamic: 'false',
+            properties: {}
         },
         values: {
             properties: {},
-        }
+        },
     }
 };
+/* eslint-enable sort-keys */
 //# sourceMappingURL=measuresMappings.js.map

package/lib/measures/MovementMeasure.d.ts

@@ -1,7 +1,7 @@
 import { Measurement, MeasureDefinition } from '../types';
-export interface MovementMeasure extends Measurement {
+export interface MovementMeasurement extends Measurement {
     values: {
-        movement: number;
+        movement: boolean;
     };
 }
 export declare const movementMeasure: MeasureDefinition;

package/lib/types/DecodedPayload.d.ts

@@ -1,4 +1,33 @@
 import { Measurement } from './measures/Measurement';
+/**
+ * Result of the `Decoder.decode` method.
+ *
+ * Contains the decoded measures.
+ *
+ * @example
+ *
+ *  const decodedPayload: DecodedPayload = {
+ *    reference: 'BZH42AZF',
+ *    measures: {
+ *      temperature: {
+ *        measuredAt: Date.now(),
+ *        values: {
+ *          temperature: 23.8,
+ *        }
+ *      },
+ *      position: {
+ *        measuredAt: Date.now(),
+ *        values: {
+ *          position: {
+ *            lat: 21.297,
+ *            lon: 4.8421,
+ *          },
+ *          accuracy: 100,
+ *        }
+ *      },
+ *    },
+ *  };
+ */
 export interface DecodedPayload {
     /**
      * Device unique reference

package/lib/types/measures/MeasureContent.d.ts

@@ -44,13 +44,13 @@ export interface MeasureContent extends KDocumentContent {
          * E.g. "AbeewayTemp"
          */
         model: string;
-        /**
-         * Reference of the data source (e.g. a device manufacturer ID)
-         */
-        reference: string;
         /**
          * Array of payload uuids that were used to create this measure.
          */
         payloadUuids: string[];
+        /**
+         * Asset ID linked to the device when the measure was made
+         */
+        assetId?: string;
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle-device-manager",
-  "version": "2.0.0-rc1",
+  "version": "2.0.0-rc3",
   "description": "Manage your IoT devices and assets. Choose a provisioning strategy, receive and decode payload, handle your IoT business logic.",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "repository": {