feat/add-mAttachTenant

doc/1/controllers/sensor/m-attach/index.md

@@ -0,0 +1,88 @@
+---
+code: true
+type: page
+title: mAttachTenant
+description: Attach multiple sensors to multiple tenants index
+---
+
+# mAttachTenant
+
+Attach multiple sensors to multiple tenants.
+
+The sensor document will be duplicated inside the tenant "sensors" collection.
+
+---
+
+## Query Syntax
+
+### HTTP
+
+``` http
+URL: http://kuzzle:7512/_/device-manager/sensors/_mAttach
+Method: PUT
+Body:
+```
+
+``` js
+{
+    // Using JSON
+    "records" [{
+        "tenantId": "tenant-kuzzle",
+        "sensorId": "test-id"
+    }],
+    // Using CSV syntax
+    "csv": "tenant,id\ntenant-kuzzle,test-id"
+}
+```
+
+### Other protocols
+
+``` js
+{
+    "controller": "device-manager/sensor",
+    "action": "mAttachTenant",
+    "body": {
+        // Using JSON
+        "records" [{
+            "tenantId": "tenant-kuzzle",
+            "sensorId": "test-id"
+        }],
+        // Using CSV syntax
+        "csv": "tenantId,sensorId\ntenant-kuzzle,test-id",
+    }
+}
+```
+
+---
+
+## Body properties
+
+Body properties, must contain at least one of
+
+- `records`: an array of object containing `tenantId` and `sensorId`
+- `csv`: a csv syntax compatible containing at least this two headers `tenantId,sensorId` with their corresponding values
+- `strict`: a boolean value that indicate if the process should fail at first error
+
+---
+
+### Optional:
+
+* `refresh`: if set to `wait_for`, Kuzzle will not respond until the documents are indexed
+
+---
+
+## Response
+
+``` js
+{
+    "status": 200,
+    "error": null,
+    "controller": "device-manager/sensor",
+    "action": "mAttachTenant",
+    "requestId": "<unique request identifier>",
+    "result": {
+        "errors": [],
+        "successes": []
+    }
+}
+```

doc/1/guides/sensors/index.md

@@ -110,6 +110,14 @@ Sensors can be attached to tenant by using the [device-manager/sensor:attach](/k
 
 When attached, the sensor document is copied inside the `sensors` collection of the tenant index.
 
+## Attach to multiple tenant
+
+Multiple different Sensors can also be attached to multiple defferents tenant by using the [device-manager/sensor:mAttach](/kuzzle-iot-platform/device-manager/1/controllers/sensor/m-attach) API action.
+
+The format used can be either __CSV__ in the form of a string in the format `tenantId,sensorId\nmytenantId,mysensorId` or __JSON__ in the form of an array of objects `"records": [{ "tenantId": "mytenantId", "sensorId": "mysensorId"}]`.
+
+When attached, all sensors documents are copied inside the `sensors` collections of all different tenant index.
+
 ## Link to an asset
 
 Sensors can be linked to an asset by using the [device-manager/sensor:link](/kuzzle-iot-platform/device-manager/1/controllers/sensor/link) API action.

features/SensorController.feature

@@ -9,6 +9,37 @@ Feature: Device Manager sensor controller
       | tenantId | "tenant-kuzzle" |
     And The document "tenant-kuzzle":"sensors":"DummyTemp_detached" exists
 
+  Scenario: Attach multiple sensors to a tenant using JSON
+    Given an engine on index "tenant-kuzzle"
+    When I successfully execute the action "device-manager/sensor":"mAttachTenant" with args:
+      | body.records.0.tenantId | "tenant-kuzzle"                    |
+      | body.records.0.sensorId | "DummyTemp_detached"               |
+      | body.records.1.tenantId | "tenant-kuzzle"                    |
+      | body.records.1.sensorId | "DummyTemp_attached-ayse-unlinked" |
+    Then The document "device-manager":"sensors":"DummyTemp_detached" content match:
+      | tenantId | "tenant-kuzzle" |
+    Then The document "device-manager":"sensors":"DummyTemp_attached-ayse-unlinked" content match:
+      | tenantId | "tenant-kuzzle" |
+    And The document "tenant-kuzzle":"sensors":"DummyTemp_detached" exists
+    And The document "tenant-kuzzle":"sensors":"DummyTemp_attached-ayse-unlinked" exists
+
+  Scenario: Attach multiple sensor to a tenant using CSV
+    Given an engine on index "tenant-kuzzle"
+    When I successfully execute the action "device-manager/sensor":"mAttachTenant" with args:
+      | body.csv | "tenantId,sensorId\\ntenant-kuzzle,DummyTemp_detached\\ntenant-kuzzle,DummyTemp_attached-ayse-unlinked," |
+    Then The document "device-manager":"sensors":"DummyTemp_detached" content match:
+      | tenantId | "tenant-kuzzle" |
+    Then The document "device-manager":"sensors":"DummyTemp_attached-ayse-unlinked" content match:
+      | tenantId | "tenant-kuzzle" |
+    And The document "tenant-kuzzle":"sensors":"DummyTemp_detached" exists
+    And The document "tenant-kuzzle":"sensors":"DummyTemp_attached-ayse-unlinked" exists
+
+  Scenario: Attach multiple sensor to a tenant while exceeding documentsWriteCount limit 
+    Given an engine on index "tenant-kuzzle"
+    When I attach multiple sensors while exeding documentsWriteCount limit
+    Then All attached sensors have the correct tenantId
+    Then All tenant sensors documents exists
+
   Scenario: Error when assigning a sensor to a tenant
     Given an engine on index "tenant-kuzzle"
     When I execute the action "device-manager/sensor":"attachTenant" with args:
@@ -23,7 +54,7 @@ Feature: Device Manager sensor controller
       | _id   | "DummyTemp_detached" |
       | index | "tenant-kuzzle"      |
     Then I should receive an error matching:
-      | message | "Sensor \"DummyTemp_detached\" is already attached to a tenant" |
+      | message | "These sensors \"DummyTemp_detached\" are already attached to a tenant" |
 
   Scenario: Detach sensor from a tenant
     Given an engine on index "tenant-kuzzle"

features/fixtures/application/app.ts

@@ -39,6 +39,7 @@ app.hook.register('request:onError', async (request: KuzzleRequest) => {
 });
 
 app.config.set('plugins.kuzzle-plugin-logger.services.stdout.level', 'debug');
+app.config.set('limits.documentsWriteCount', 20);
 
 app.start()
   .then(() => {

features/fixtures/fixtures.js

@@ -1,6 +1,9 @@
+const sensors = require('./sensors');
+
 module.exports = {
   'device-manager': {
     sensors: [
+      ...sensors,
       { index: { _id: 'DummyTemp_detached' } },
       {
         reference: 'detached',

features/fixtures/sensors.js

@@ -0,0 +1,14 @@
+const sensors = [];
+for (let i = 0; i < 50; i++) {
+  sensors.push({ index: { _id: `DummyTemp_detached-${i}` } });
+  sensors.push({
+    reference: 'detached',
+    model: `DummyTemp-${i}`,
+    measures: {},
+    metadata: {},
+    tenantId: null,
+    assetId: null
+  });
+}
+
+module.exports = sensors;

features/step_definitions/sensor-controller-steps.js

@@ -0,0 +1,52 @@
+const { When, Then } = require('cucumber');
+
+When('I attach multiple sensors while exeding documentsWriteCount limit', async function () {
+	const records = [];
+	for (let i = 0; i < 50; i++) {
+		records.push({ sensorId: `DummyTemp_detached-${i}`, tenantId: 'tenant-kuzzle' });
+	}
+
+
+	await this.sdk.query({
+		controller: "device-manager/sensor",
+		action: "mAttachTenant",
+		body: {
+			records
+		}
+	});
+});
+
+Then('All attached sensors have the correct tenantId', async function () {
+	const sensorIds = [];
+	for (let i = 0; i < 50; i++) {
+		sensorIds.push(`DummyTemp_detached-${i}`);
+	}
+
+	const { successes, errors } = await this.sdk.document.mGet('device-manager', 'sensors', sensorIds);
+
+	if (errors.length > 0) {
+		throw new Error(errors);
+	}
+
+	for (let i = 0; i < successes.length; i++) {
+		const { _source } = successes[i];
+		if (_source.tenantId !== 'tenant-kuzzle') {
+			throw new Error('tenantId should be tenant-kuzzle but current value is: ', _source.tenantId);
+		}
+	}
+});
+
+
+Then('All tenant sensors documents exists', async function () {
+	const sensorIds = [];
+	for (let i = 0; i < 50; i++) {
+		sensorIds.push(`DummyTemp_detached-${i}`);
+	}
+
+	const { errors } = await this.sdk.document.mGet('tenant-kuzzle', 'sensors', sensorIds);
+
+	if (errors.length > 0) {
+		throw new Error(errors);
+	}
+});
+

lib/controllers/SensorController.ts

@@ -1,23 +1,27 @@
+import csv from 'csvtojson';
 import {
   KuzzleRequest,
   EmbeddedSDK,
   JSONObject,
   PluginContext,
+  BadRequestError
 } from 'kuzzle';
 
+
 import { CRUDController } from './CRUDController';
 import { Decoder } from '../decoders';
 import { Sensor } from '../models';
+import { SensorBulkContent } from '../types';
 import { SensorService } from '../services';
 
 export class SensorController extends CRUDController {
   private decoders: Map<string, Decoder>;
 
-  get sdk (): EmbeddedSDK {
+  get sdk(): EmbeddedSDK {
     return this.context.accessors.sdk;
   }
 
-  constructor (config: JSONObject, context: PluginContext, decoders: Map<string, Decoder>, sensorService: SensorService) {
+  constructor(config: JSONObject, context: PluginContext, decoders: Map<string, Decoder>, sensorService: SensorService) {
     super(config, context, 'sensors');
 
     this.decoders = decoders;
@@ -41,6 +45,10 @@ export class SensorController extends CRUDController {
           handler: this.attachTenant.bind(this),
           http: [{ verb: 'put', path: 'device-manager/:index/sensors/:_id/_attach' }]
         },
+        mAttachTenant: {
+          handler: this.mAttachTenant.bind(this),
+          http: [{ verb: 'put', path: 'device-manager/sensors/_mAttach' }]
+        },
         detach: {
           handler: this.detach.bind(this),
           http: [{ verb: 'delete', path: 'device-manager/sensors/:_id/_detach' }]
@@ -64,11 +72,25 @@ export class SensorController extends CRUDController {
     const tenantId = this.getIndex(request);
     const sensorId = this.getId(request);
 
-    const sensor = await this.getSensor(sensorId);
+    const document = { tenantId: tenantId, sensorId: sensorId };
+    const sensors = await this.mGetSensor([document]);
 
-    await this.sensorService.attachTenant(sensor, tenantId);
+    await this.sensorService.mAttachTenant(sensors, [document], { strict: true });
   }
 
+  /**
+   * Attach multiple sensors to multiple tenants
+   */
+  async mAttachTenant (request: KuzzleRequest) {
+    const { bulkData, strict } = await this.mParseRequest(request);
+
+    const sensors = await this.mGetSensor(bulkData);
+
+    return this.sensorService.mAttachTenant(sensors, bulkData, { strict });
+  }
+
+
+
   /**
    * Unattach a sensor from it's tenant
    */
@@ -83,7 +105,7 @@ export class SensorController extends CRUDController {
   /**
    * Link a sensor to an asset.
    */
-  async linkAsset (request: KuzzleRequest) {
+  async linkAsset(request: KuzzleRequest) {
     const assetId = this.getString(request, 'assetId');
     const sensorId = this.getId(request);
 
@@ -111,4 +133,37 @@ export class SensorController extends CRUDController {
 
     return new Sensor(document._source, document._id);
   }
+
+  private async mGetSensor (sensors: SensorBulkContent[]): Promise<Sensor[]> {
+    const sensorIds = sensors.map(doc => doc.sensorId);
+    const result: any = await this.sdk.document.mGet(
+      this.config.adminIndex,
+      'sensors',
+      sensorIds
+    )
+    return result.successes.map((document: any) => new Sensor(document._source, document._id));
+  }
+
+  private async mParseRequest (request: KuzzleRequest) {
+    const { body } = request.input;
+
+    let bulkData: SensorBulkContent[];
+
+    if (body.csv) {
+      const lines = await csv({ delimiter: 'auto' })
+        .fromString(body.csv);
+
+      bulkData = lines.map(line => ({ tenantId: line.tenantId, sensorId: line.sensorId }));
+    }
+    else if (body.records) {
+      bulkData = body.records;
+    }
+    else {
+      throw new BadRequestError(`Malformed request missing property csv or records`);
+    }
+
+    const strict = body.strict || false;
+
+    return { strict, bulkData };
+  }
 }