kuzzle-device-manager 2.0.0-rc3 → 2.0.0-rc4

package/lib/DeviceManagerPlugin.d.ts

@@ -1,4 +1,4 @@
-import { Plugin, PluginContext, JSONObject } from 'kuzzle';
+import { Plugin, PluginContext, JSONObject, KuzzleRequest } from 'kuzzle';
 import { AssetsRegister, DevicesRegister, MeasuresRegister, DecodersRegister } from './core-classes';
 import { DeviceManagerConfiguration } from './types';
 export declare class DeviceManagerPlugin extends Plugin {
@@ -7,10 +7,16 @@ export declare class DeviceManagerPlugin extends Plugin {
     private deviceController;
     private decodersController;
     private engineController;
+    private assetCategoryController;
+    private metadataController;
+    private treeNodeController;
+    private batchController;
     private assetService;
+    private assetCategoryService;
     private payloadService;
     private deviceManagerEngine;
     private deviceService;
+    private measuresService;
     private decodersRegister;
     private measuresRegister;
     private devicesRegister;
@@ -45,6 +51,7 @@ export declare class DeviceManagerPlugin extends Plugin {
      */
     get decoders(): DecodersRegister;
     constructor();
+    unknowPayload(request: KuzzleRequest): Promise<void>;
     /**
      * Init the plugin
      */

package/lib/DeviceManagerPlugin.js

@@ -11,6 +11,10 @@ const controllers_1 = require("./controllers");
 const core_classes_1 = require("./core-classes");
 const measures_1 = require("./measures");
 const mappings_1 = require("./mappings");
+const AssetCategoryController_1 = require("./controllers/AssetCategoryController");
+const MetadataController_1 = require("./controllers/MetadataController");
+const AssetCategoryService_1 = require("./core-classes/AssetCategoryService");
+const MeasureService_1 = require("./core-classes/MeasureService");
 class DeviceManagerPlugin extends kuzzle_1.Plugin {
     constructor() {
         super({
@@ -61,6 +65,11 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
             batchInterval: 10
         };
         /* eslint-enable sort-keys */
+        this.measures.register('temperature', measures_1.temperatureMeasure);
+        this.measures.register('position', measures_1.positionMeasure);
+        this.measures.register('movement', measures_1.movementMeasure);
+        this.measures.register('humidity', measures_1.humidityMeasure);
+        this.measures.register('battery', measures_1.batteryMeasure);
     }
     get sdk() {
         return this.context.accessors.sdk;
@@ -99,6 +108,15 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
     get decoders() {
         return this.decodersRegister;
     }
+    async unknowPayload(request) {
+        const body = request.getBody();
+        const device = request.getString('device');
+        const documentContent = {
+            deviceModel: device,
+            rawPayload: body
+        };
+        this.sdk.document.create('device-manager', 'payloads', documentContent);
+    }
     /**
      * Init the plugin
      */
@@ -134,24 +152,32 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
             mappings: this.config.engineCollections.config.mappings,
             settings: this.config.engineCollections.config.settings,
         });
-        this.measures.register('temperature', measures_1.temperatureMeasure);
-        this.measures.register('position', measures_1.positionMeasure);
-        this.measures.register('movement', measures_1.movementMeasure);
-        this.measures.register('humidity', measures_1.humidityMeasure);
-        this.measures.register('battery', measures_1.batteryMeasure);
-        this.assetService = new core_classes_1.AssetService(this);
-        this.payloadService = new core_classes_1.PayloadService(this, this.measuresRegister);
-        this.deviceService = new core_classes_1.DeviceService(this);
+        this.assetCategoryService = new AssetCategoryService_1.AssetCategoryService(this);
+        this.batchController = new kuzzle_1.BatchController(this.sdk, {
+            interval: this.config.batchInterval
+        });
+        this.assetService = new core_classes_1.AssetService(this, this.batchController);
+        this.deviceService = new core_classes_1.DeviceService(this, this.batchController, this.assetService, this.decodersRegister);
+        this.measuresService = new MeasureService_1.MeasureService(this, this.batchController, this.deviceService, this.assetService, this.measuresRegister);
+        this.payloadService = new core_classes_1.PayloadService(this, this.batchController, this.measuresRegister, this.measuresService);
         this.deviceManagerEngine = new core_classes_1.DeviceManagerEngine(this, this.assetsRegister, this.devicesRegister, this.measuresRegister, this.adminConfigManager, this.engineConfigManager);
         this.decodersRegister.init(this.context);
-        this.assetController = new controllers_1.AssetController(this, this.assetService);
+        this.assetController = new controllers_1.AssetController(this, this.assetService, this.deviceService, this.assetCategoryService, this.measuresService);
         this.deviceController = new controllers_1.DeviceController(this, this.deviceService);
         this.decodersController = new controllers_1.DecodersController(this, this.decodersRegister);
         this.engineController = new kuzzle_plugin_commons_1.EngineController('device-manager', this, this.deviceManagerEngine);
+        this.assetCategoryController = new AssetCategoryController_1.AssetCategoryController(this, this.assetCategoryService);
+        this.metadataController = new MetadataController_1.MetadataController(this, this.assetCategoryService);
         this.api['device-manager/payload'] = this.decodersRegister.getPayloadController(this.payloadService);
         this.api['device-manager/asset'] = this.assetController.definition;
         this.api['device-manager/device'] = this.deviceController.definition;
         this.api['device-manager/decoders'] = this.decodersController.definition;
+        this.api['device-manager/assetCategory'] = this.assetCategoryController.definition;
+        this.api['device-manager/metadata'] = this.metadataController.definition;
+        this.api['device-manager/payload'].actions.generic = {
+            handler: this.unknowPayload.bind(this),
+            http: [{ path: 'device-manager/payload/:device', verb: 'post' }]
+        };
         this.hooks = {
             'kuzzle:state:live': async () => {
                 await this.decodersRegister.createDefaultRights();

package/lib/InternalCollection.d.ts

@@ -0,0 +1,5 @@
+export declare enum InternalCollection {
+    ASSETS = "assets",
+    DEVICES = "devices",
+    MEASURES = "measures"
+}

package/lib/InternalCollection.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalCollection = void 0;
+var InternalCollection;
+(function (InternalCollection) {
+    InternalCollection["ASSETS"] = "assets";
+    InternalCollection["DEVICES"] = "devices";
+    InternalCollection["MEASURES"] = "measures";
+})(InternalCollection = exports.InternalCollection || (exports.InternalCollection = {}));
+//# sourceMappingURL=InternalCollection.js.map

package/lib/controllers/AssetCategoryController.d.ts

@@ -0,0 +1,28 @@
+import { KuzzleRequest, Plugin } from 'kuzzle';
+import { RelationalController } from './RelationalController';
+import { ProcessedAssetCategoryContent } from '../types/AssetCategoryContent';
+import { AssetCategoryService } from '../core-classes/AssetCategoryService';
+export declare class AssetCategoryController extends RelationalController {
+    private assetCategoryService;
+    constructor(plugin: Plugin, assetCategoryService: AssetCategoryService);
+    create(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    update(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    delete(request: KuzzleRequest): Promise<string>;
+    linkParent(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    unlinkParent(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    unlinkMetadata(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    linkMetadata(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    get(request: KuzzleRequest): Promise<ProcessedAssetCategoryContent>;
+}

package/lib/controllers/AssetCategoryController.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetCategoryController = void 0;
+const RelationalController_1 = require("./RelationalController");
+class AssetCategoryController extends RelationalController_1.RelationalController {
+    constructor(plugin, assetCategoryService) {
+        super(plugin, 'asset-category');
+        this.assetCategoryService = assetCategoryService;
+        global.app.errors.register('device-manager', 'relational_controller', 'forbidden_parent', {
+            class: 'BadRequestError',
+            description: 'you can\'t have a parent that is a subcategory',
+            message: 'you can\'t have a parent that is a subcategory',
+        });
+        /* eslint-disable sort-keys */
+        this.definition = {
+            actions: {
+                get: {
+                    handler: this.get.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assetCategory/:_id', verb: 'get' }],
+                },
+                create: {
+                    handler: this.create.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assetCategory', verb: 'post' }],
+                },
+                delete: {
+                    handler: this.delete.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assetCategory/:_id', verb: 'delete' }],
+                },
+                update: {
+                    handler: this.update.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assetCategory/:_id', verb: 'put' }],
+                },
+                linkMetadata: {
+                    handler: this.linkMetadata.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assetCategory/:_id/_link/metadata/:metadataId', verb: 'put' }],
+                },
+                unlinkMetadata: {
+                    handler: this.unlinkMetadata.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assetCategory/:_id/_unlink/metadata/:metadataId', verb: 'delete' }],
+                },
+                linkParent: {
+                    handler: this.linkParent.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assetCategory/:_id/_link/parent/:parentId', verb: 'put' }],
+                },
+                unlinkParent: {
+                    handler: this.unlinkParent.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assetCategory/:_id/_unlink/parent/:parentId', verb: 'delete' }],
+                }
+            },
+        };
+    }
+    async create(request) {
+        request.input.resource._id = request.input.body.name;
+        let metadataValues = request.input.body.metadataValues;
+        let assetMetadata = request.input.body.assetMetadata;
+        if (!assetMetadata) {
+            request.input.body.assetMetadata = [];
+        }
+        if (!metadataValues) {
+            request.input.body.metadataValues = [];
+        }
+        else {
+            const metadataValuesTable = [];
+            for (const [key, value] of Object.entries(metadataValues)) {
+                metadataValuesTable.push({ key, value });
+            }
+            request.input.body.metadataValues = metadataValuesTable;
+        }
+        return super.create(request);
+    }
+    async update(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const assetMetadata = request.input.body.assetMetadata;
+        if (assetMetadata) {
+            //if elemets are removed in assetMetadata, we need to also remove the values associated in metadataValues
+            if (!request.input.body.metadataValues) {
+                const document = await this.sdk.document.get(engineId, this.collection, id);
+                request.input.body.metadataValues = document._source.metadataValues;
+            }
+            let index = 0;
+            const metadataValues = request.input.body.metadataValues;
+            for (const values of metadataValues) {
+                if (!assetMetadata.includes(values.key)) {
+                    metadataValues.splice(index);
+                }
+                else {
+                    index++;
+                }
+            }
+        }
+        return super.genericUpdate(request);
+    }
+    async delete(request) {
+        const linkedAsset = this.getFieldPath(request, 'category', null, 'assets');
+        const children = this.getFieldPath(request, 'parent');
+        return super.genericDelete(request, [], [], [linkedAsset, children]);
+    }
+    async linkParent(request) {
+        const parent = request.getString('parentId');
+        const document = await this.sdk.document.get(request.getString('engineId'), 'asset-category', parent);
+        if (document._source.parentId) {
+            throw global.app.errors.get('device-manager', 'asset_controller', 'forbidden_parent');
+        }
+        request.input.body = {
+            parent
+        };
+        return this.update(request);
+    }
+    async unlinkParent(request) {
+        request.input.body = {
+            'parent': null
+        };
+        return this.update(request);
+    }
+    async unlinkMetadata(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const metadataId = request.getString('metadataId');
+        const category = await this.sdk.document.get(engineId, 'asset-category', id);
+        const updatedMetadata = category._source.assetMetadata.filter(ownedMetadataId => ownedMetadataId !== metadataId);
+        request.input.body = {
+            assetMetadata: updatedMetadata
+        };
+        return this.update(request);
+    }
+    async linkMetadata(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const metadataId = request.getString('metadataId');
+        const value = request.input.body?.value;
+        const [metadataContent, category] = await Promise.all([
+            await this.sdk.document.get(engineId, 'metadata', metadataId),
+            await this.sdk.document.get(engineId, 'asset-category', id)
+        ]);
+        const metadata = category._source.assetMetadata ? category._source.assetMetadata : [];
+        let metadataValues = category._source.metadataValues;
+        if (metadata.includes(metadataId)) {
+            throw global.app.errors.get('device-manager', 'relational_controller', 'link_already_exist');
+        }
+        metadata.push(metadataId);
+        request.input.body = {
+            assetMetadata: metadata
+        };
+        let update = false;
+        if (value) {
+            this.assetCategoryService.validateEnumMetadata(metadataContent._source, value);
+            const formattedValue = this.assetCategoryService.formatValue(value);
+            if (metadataValues) {
+                for (const metadataValue of metadataValues) {
+                    if (metadataValue.key === metadataId) {
+                        metadataValue.value = formattedValue;
+                        update = true;
+                    }
+                }
+            }
+            else {
+                metadataValues = [];
+            }
+            if (!update) {
+                metadataValues.push({ key: metadataId, value: formattedValue });
+            }
+            request.input.body.metadataValues = metadataValues;
+        }
+        return this.update(request);
+    }
+    async get(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const category = await this.sdk.document.get(engineId, 'asset-category', id);
+        const categorySource = category._source;
+        const [assetMetadata, metadataValues] = await Promise.all([
+            this.assetCategoryService.getMetadata(categorySource, engineId),
+            this.assetCategoryService.getMetadataValues(categorySource, engineId)
+        ]);
+        const formattedAssetMetadata = this.assetCategoryService.formatMetadataForGet(metadataValues);
+        const children = this.getFieldPath(request, 'parent');
+        const processedCategory = await this.genericGet(engineId, this.collection, id, [children]);
+        const processedAssetCategoryContent = {
+            name: categorySource.name,
+            parent: processedCategory._source.parent,
+            assetMetadata,
+            metadataValues: formattedAssetMetadata
+        };
+        return processedAssetCategoryContent;
+    }
+}
+exports.AssetCategoryController = AssetCategoryController;
+//# sourceMappingURL=AssetCategoryController.js.map

package/lib/controllers/AssetController.d.ts

@@ -1,13 +1,41 @@
-import { CRUDController } from 'kuzzle-plugin-commons';
-import { KuzzleRequest, Plugin } from 'kuzzle';
-import { AssetService } from '../core-classes';
-export declare class AssetController extends CRUDController {
+import { JSONObject, KuzzleRequest, Plugin } from 'kuzzle';
+import { BaseAsset } from '../models/BaseAsset';
+import { AssetService, DeviceService } from '../core-classes';
+import { AssetCategoryService } from '../core-classes/AssetCategoryService';
+import { RelationalController } from './RelationalController';
+import { MeasureService } from 'lib/core-classes/MeasureService';
+export declare class AssetController extends RelationalController {
     private assetService;
-    private get sdk();
-    constructor(plugin: Plugin, assetService: AssetService);
-    measures(request: KuzzleRequest): Promise<{
+    private deviceService;
+    private assetCategoryService;
+    private measureService;
+    constructor(plugin: Plugin, assetService: AssetService, deviceService: DeviceService, assetCategoryService: AssetCategoryService, measureService: MeasureService);
+    mRemoveMeasures(request: KuzzleRequest): Promise<{
+        notFound: string[];
+        removed: any[];
+        asset: BaseAsset;
+    }>;
+    removeMeasure(request: KuzzleRequest): Promise<{
+        notFound: string[];
+        removed: any[];
+        asset: BaseAsset;
+    }>;
+    getMeasures(request: KuzzleRequest): Promise<{
         measures: import("kuzzle").KDocument<import("../types").MeasureContent>[];
     }>;
+    get(request: KuzzleRequest): Promise<JSONObject>;
+    unlinkCategory(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    linkCategory(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    pushMeasures(request: KuzzleRequest): Promise<{
+        asset: JSONObject | (() => JSONObject);
+        engineId: string;
+        invalids: JSONObject[];
+        valids: any[] | import("../types").MeasureContent[];
+    }>;
     update(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
         [x: string]: any;
     }>>;

package/lib/controllers/AssetController.js

@@ -5,51 +5,98 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 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) {
+const RelationalController_1 = require("./RelationalController");
+class AssetController extends RelationalController_1.RelationalController {
+    constructor(plugin, assetService, deviceService, assetCategoryService, measureService) {
         super(plugin, 'assets');
+        global.app.errors.register('device-manager', 'asset_controller', 'mandatory_metadata', {
+            class: 'BadRequestError',
+            description: 'Metadata which are specified in AssetCategory as mandatory must be present',
+            message: 'metadata %s is mandatory for the asset',
+        });
+        global.app.errors.register('device-manager', 'asset_controller', 'enum_metadata', {
+            class: 'BadRequestError',
+            description: 'Metadata must have one of the values specified in metadata valueList',
+            message: 'metadata %s cannot have %s value : value must have one of the value of metadata valueList ',
+        });
+        this.assetCategoryService = assetCategoryService;
         this.assetService = assetService;
+        this.deviceService = deviceService;
+        this.measureService = measureService;
         /* eslint-disable sort-keys */
         this.definition = {
             actions: {
                 create: {
                     handler: this.create.bind(this),
-                    http: [{ path: 'device-manager/:index/assets', verb: 'post' }],
+                    http: [{ path: 'device-manager/:engineId/assets', verb: 'post' }],
                 },
                 delete: {
                     handler: this.delete.bind(this),
-                    http: [{ path: 'device-manager/:index/assets/:_id', verb: 'delete' }],
+                    http: [{ path: 'device-manager/:engineId/assets/:_id', verb: 'delete' }],
+                },
+                get: {
+                    handler: this.get.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assets/:_id', verb: 'get' }],
                 },
                 importAssets: {
                     handler: this.importAssets.bind(this),
-                    http: [{ path: 'device-manager/:index/assets/_import', verb: 'post' }]
+                    http: [{ path: 'device-manager/:engineId/assets/_import', verb: 'post' }]
                 },
                 search: {
                     handler: this.search.bind(this),
                     http: [
-                        { path: 'device-manager/:index/assets/_search', verb: 'post' },
-                        { path: 'device-manager/:index/assets/_search', verb: 'get' },
+                        { path: 'device-manager/:engineId/assets/_search', verb: 'post' },
+                        { path: 'device-manager/:engineId/assets/_search', verb: 'get' },
                     ],
                 },
                 update: {
                     handler: this.update.bind(this),
-                    http: [{ path: 'device-manager/:index/assets/:_id', verb: 'put' }],
+                    http: [{ path: 'device-manager/:engineId/assets/:_id', verb: 'put' }],
+                },
+                getMeasures: {
+                    handler: this.getMeasures.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assets/:_id/measures', verb: 'get' }],
+                },
+                linkCategory: {
+                    handler: this.linkCategory.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assets/:_id/_link/category/:categoryId', verb: 'put' }],
+                },
+                unlinkCategory: {
+                    handler: this.unlinkCategory.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assets/:_id/_unlink/category/:categoryId', verb: 'delete' }],
+                },
+                pushMeasures: {
+                    handler: this.pushMeasures.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assets/:_id/measures', verb: 'post' }],
+                },
+                removeMeasure: {
+                    handler: this.removeMeasure.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assets/:_id/measures/:assetMeasureName', verb: 'delete' }],
+                },
+                mRemoveMeasures: {
+                    handler: this.mRemoveMeasures.bind(this),
+                    http: [{ path: 'device-manager/:engineId/assets/:_id/measures', verb: 'delete' }],
                 },
-                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 mRemoveMeasures(request) {
+        const id = request.getId();
+        const strict = request.getBoolean('strict');
+        const engineId = request.getString('engineId');
+        const assetMeasureNames = request.getBodyArray('assetMeasureNames');
+        return this.assetService.removeMeasures(engineId, id, assetMeasureNames, { strict });
     }
-    async measures(request) {
+    async removeMeasure(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const assetMeasureName = request.getString('assetMeasureName');
+        return this.assetService.removeMeasures(engineId, id, [assetMeasureName], { strict: true });
+    }
+    async getMeasures(request) {
         const id = request.getId();
         const engineId = request.getString('engineId');
         const size = request.input.args.size;
@@ -61,11 +108,69 @@ class AssetController extends kuzzle_plugin_commons_1.CRUDController {
         const measures = await this.assetService.measureHistory(engineId, id, { endAt, size, startAt });
         return { measures };
     }
+    async get(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const category = this.getFieldPath(request, 'category', null, 'asset-category');
+        const document = await this.genericGet(engineId, this.collection, id, [category]);
+        const metadata = document._source.metadata;
+        const asset = document._source;
+        if (metadata) {
+            asset.metadata = await this.assetCategoryService.formatMetadataForGet(metadata);
+        }
+        return asset;
+    }
+    async unlinkCategory(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const categoryId = request.getString('categoryId');
+        const document = await this.sdk.document.get(engineId, this.collection, id);
+        if (document._source.category !== categoryId && document._source.subCategory !== categoryId) {
+            throw global.app.errors.get('device-manager', 'relational_controller', 'remove_unexisting_link');
+        }
+        request.input.body = { category: null, subCategory: null };
+        return this.update(request);
+    }
+    async linkCategory(request) {
+        const id = request.getId();
+        const engineId = request.getString('engineId');
+        const categoryId = request.getString('categoryId');
+        const document = await this.sdk.document.get(engineId, this.collection, id);
+        const categoryDocument = await this.sdk.document.get(engineId, 'asset-category', categoryId);
+        const updateRequest = {
+            category: null,
+            subCategory: null
+        };
+        if (document._source.category) {
+            throw global.app.errors.get('device-manager', 'relational_controller', 'already_linked', 'asset', 'category');
+        }
+        else if (categoryDocument._source.parent) {
+            updateRequest.category = categoryDocument._source.parent;
+            updateRequest.subCategory = request.getString('categoryId');
+        }
+        else {
+            updateRequest.category = request.getString('categoryId');
+        }
+        request.input.body = updateRequest;
+        return this.update(request);
+    }
+    async pushMeasures(request) {
+        const engineId = request.getString('engineId');
+        const assetId = request.getId();
+        const refresh = request.getRefresh();
+        const strict = request.getBoolean('strict');
+        const measures = request.getBodyArray('measures');
+        const kuid = request.getKuid();
+        const { asset, invalids, valids } = await this.measureService.registerByAsset(engineId, assetId, measures, kuid, { refresh, strict });
+        return { asset, engineId, invalids, valids };
+    }
     async update(request) {
         const id = request.getId();
         const engineId = request.getString('engineId');
         const body = request.getBody();
         const asset = await this.sdk.document.get(engineId, this.collection, id);
+        let assetMetadata = request.input.body.metadata;
+        request.input.body.metadata = await this.assetCategoryService.formatMetadataForES(assetMetadata);
         const response = await global.app.trigger('device-manager:asset:update:before', {
             asset,
             updates: body
@@ -80,13 +185,30 @@ class AssetController extends kuzzle_plugin_commons_1.CRUDController {
         return result;
     }
     async create(request) {
+        const engineId = request.getString('engineId');
         const type = request.getBodyString('type');
         const model = request.getBodyString('model');
         const reference = request.getBodyString('reference');
+        const category = request.getBody().category;
+        let assetMetadata = request.getBodyObject('metadata', {});
+        if (category) {
+            await this.assetCategoryService.validateMetadata(assetMetadata, engineId, category);
+            const assetCategory = await this.sdk.document.get(engineId, 'asset-category', category);
+            const values = await this.assetCategoryService.getMetadataValues(assetCategory._source, engineId);
+            request.input.body.metadata = await this.assetCategoryService.formatMetadataForES(assetMetadata);
+            request.input.body.metadata = request.input.body.metadata.concat(values);
+        }
+        else {
+            request.input.body.metadata = await this.assetCategoryService.formatMetadataForES(assetMetadata);
+            request.input.body.category = null;
+        }
         if (!request.input.args._id) {
             request.input.args._id = BaseAsset_1.BaseAsset.id(type, model, reference);
         }
-        request.input.args.index = request.getString('engineId');
+        request.input.args.index = engineId;
+        request.input.body.measures = [];
+        request.input.body.deviceLinks = [];
+        request.input.body.measures = [];
         return super.create(request);
     }
     async importAssets(request) {
@@ -100,7 +222,18 @@ class AssetController extends kuzzle_plugin_commons_1.CRUDController {
         return results;
     }
     async delete(request) {
-        request.input.args.index = request.getString('engineId');
+        const engineId = request.getString('engineId');
+        request.input.args.index = engineId;
+        const assetId = request.getId();
+        const refresh = request.getRefresh();
+        const strict = request.getBoolean('strict');
+        const devicesLinks = await this.assetService.getAsset(engineId, assetId);
+        if (Array.isArray(devicesLinks._source.deviceLinks)) {
+            for (const deviceLink of devicesLinks._source.deviceLinks) {
+                // TODO : Refacto to only get the asset one time
+                await this.deviceService.unlinkAsset(deviceLink.deviceId, { refresh, strict });
+            }
+        }
         return super.delete(request);
     }
 }

package/lib/controllers/DecodersController.js

@@ -19,7 +19,7 @@ class DecodersController {
      * List all available decoders
      */
     async list() {
-        const decoders = await this.decodersRegister.list();
+        const decoders = this.decodersRegister.list();
         return { decoders };
     }
 }