feat: update measure model for localization

doc/2/concepts/models/index.md

@@ -69,6 +69,7 @@ A measure model contains the following information:
 - `measure`: type of the measure
 - `valuesMappings`: measurements mappings (See [Collection Mappings](https://docs.kuzzle.io/core/2/guides/main-concepts/data-storage/#collection-mappings))
 - `valuesDetails`: (optional) Metadata and translations of measurements. You can use it to keep consistency on translations between your apps
+- `locales`: (optional) Translation for the measure model
 
 It is possible to create new models on the Kuzzle IoT Platform using either:
 
@@ -98,6 +99,16 @@ await sdk.query({
         },
       },
     },
+    locales: {
+      en: {
+        friendlyName: "Light measurement",
+        description: "Light measurement",
+      },
+      fr: {
+        friendlyName: "Mesure de lumière",
+        description: "Mesure de lumière",
+      },
+    }
   },
 });
 ```
@@ -124,6 +135,7 @@ An asset model contains the following information:
   - Editor hint: it unlock functionalities depending on the metadata type you define.
 - `metadataGroups`: (optional) Map of group names to their translations. You can use it to group metadata.
 - `tooltipModels`: (optional) Tooltip model list, each containing labels and tooltip content to be shown. You can use it to create templates that displays relevant information in dashboards
+- `locales`: (optional) Translation for asset model
 
 It is possible to create new models on the Kuzzle IoT Platform using either:
 
@@ -150,10 +162,22 @@ import {
           { name: "temperatureInternal", type: "temperature" },
           { name: "temperatureExternal", type: "temperature" },
         ],
+        locales: {
+          en: {
+            friendlyName: "Container translated by model",
+            description: "Containerized container",
+          },
+          fr: {
+            friendlyName: "Conteneur traduit par modèle",
+            description: "Conteneur conteneurisé",
+          },
+        }
       },
     };
 ```
 
+**INFO: If the locales has changed, use [updateModelLocales](../../controllers/assets/updateModelLocales/index.md) to update all assets manually and make the search on assets up to date**
+
 The API also allows to:
 
 - list available models `device-manager/models:listAssets`

doc/2/controllers/assets/updateModelLocales/index.md

@@ -0,0 +1,55 @@
+---
+code: true
+type: page
+title: updateModelLocales
+description: Update all assets localization
+---
+
+# update
+
+Update all assets localization.
+
+The `updateModelLocales` operation allows you to update the `locales` of all `assets` related to the specified `asset model`.
+The process retrieve the locales values stored in the asset model and update the locales of all the assets with these values. For the moment, this operation has to be done `manually` when the asset model locales changed to make the `search` operation on assets to `be up to date`.
+
+## Query Syntax
+
+### HTTP
+
+```http
+URL: http://kuzzle:7512/_/device-manager/assets/modelLocales
+Method: PUT
+```
+
+## Other protocols
+
+```js
+{
+  "controller": "device-manager/assets",
+  "action": "updateModelLocales",
+  "model": "Container",
+  "engineGroup": "commons"
+}
+```
+
+## Arguments
+
+- `engineGroup`: Engine group
+- `model`: asset model
+
+## Response
+
+```js
+{
+	"action": "updateModelLocales",
+	"collection": "assets",
+	"controller": "device-manager/assets",
+	"error": null,
+	"headers": {},
+	"index": "engine-ayse",
+	"node": "knode-gigantic-iago-99422",
+	"requestId": "3b86b6d1-8004-4273-ba03-94526b019b8a",
+	"status": 200,
+	"volatile": null
+}
+```

lib/modules/asset/AssetService.ts

@@ -44,6 +44,7 @@ import {
 import {
   AssetHistoryContent,
   AssetHistoryEventMetadata,
+  AssetHistoryEventModelLocales,
 } from "./types/AssetHistoryContent";
 
 export class AssetService extends DigitalTwinService {
@@ -314,6 +315,7 @@ export class AssetService extends DigitalTwinService {
             measures,
             metadata: { ...assetMetadata, ...metadata },
             model,
+            modelLocales: assetModel.asset.locales,
             reference,
             softTenant: [],
           },
@@ -598,6 +600,82 @@ export class AssetService extends DigitalTwinService {
     return replacedAssets;
   }
 
+  /**
+   * Retrieve locales with the specified model and search all assets related to the model to update the locales.
+   * The operation is historized.
+   * @param request
+   * @param engineGroup
+   * @param model
+   */
+  public async updateModelLocales(
+    request: KuzzleRequest,
+    engineGroup: string,
+    model: string,
+  ): Promise<void> {
+    const { result } = await this.sdk.query({
+      action: "getAsset",
+      body: {},
+      controller: "device-manager/models",
+      engineGroup,
+      model,
+    });
+
+    const locales = result._source.asset.locales;
+
+    const engines = await ask<AskEngineList>("ask:device-manager:engine:list", {
+      group: engineGroup,
+    });
+
+    const targets = engines.map((engine) => ({
+      collections: [InternalCollection.ASSETS],
+      index: engine.index,
+    }));
+
+    const assets = await this.sdk.query<
+      BaseRequest,
+      DocumentSearchResult<AssetContent>
+    >({
+      action: "search",
+      body: { query: { equals: { model } } },
+      controller: "document",
+      lang: "koncorde",
+      targets,
+    });
+
+    assets.result.hits.map((asset) => {
+      asset._source.modelLocales = locales;
+    });
+
+    for (const asset of assets.result.hits) {
+      const updatedAsset = await this.updateDocument<AssetContent>(
+        request,
+        {
+          _id: asset._id,
+          _source: { modelLocales: locales },
+        },
+        {
+          collection: InternalCollection.ASSETS,
+          engineId: asset.index,
+        },
+        { source: true },
+      );
+
+      await this.assetHistoryService.add<AssetHistoryEventModelLocales>(
+        asset.index,
+        [
+          {
+            asset: updatedAsset._source,
+            event: {
+              name: "modelLocales",
+            },
+            id: updatedAsset._id,
+            timestamp: Date.now(),
+          },
+        ],
+      );
+    }
+  }
+
   private async getEngine(engineId: string): Promise<JSONObject> {
     const engine = await this.sdk.document.get(
       this.config.adminIndex,

lib/modules/asset/AssetsController.ts

@@ -204,6 +204,15 @@ export class AssetsController {
             },
           ],
         },
+        updateModelLocales: {
+          handler: this.updateModelLocales.bind(this),
+          http: [
+            {
+              path: "device-manager/assets/modelLocales",
+              verb: "patch",
+            },
+          ],
+        },
       },
     };
     /* eslint-enable sort-keys */
@@ -745,4 +754,16 @@ export class AssetsController {
 
     return this.assetService.mGetLastMeasuredAt(engineId, assetIds);
   }
+
+  /**
+   * Update modelLocales of all assets related to the specified asset model.
+   * This operation is done to make the search assets feature  up to date
+   * @param request
+   */
+  async updateModelLocales(request: KuzzleRequest): Promise<void> {
+    const model = request.getString("model");
+    const engineGroup = request.getString("engineGroup", "commons");
+
+    await this.assetService.updateModelLocales(request, engineGroup, model);
+  }
 }

lib/modules/asset/collections/assetsMappings.ts

@@ -12,6 +12,33 @@ export const assetsMappings: CollectionMappings = {
       type: "keyword",
       fields: { text: { type: "text" } },
     },
+    modelLocales: {
+      dynamic: "false",
+      properties: {
+        en: {
+          properties: {
+            description: {
+              type: "text",
+            },
+            friendlyName: {
+              type: "keyword",
+              fields: { text: { type: "text" } },
+            },
+          },
+        },
+        fr: {
+          properties: {
+            description: {
+              type: "text",
+            },
+            friendlyName: {
+              type: "keyword",
+              fields: { text: { type: "text" } },
+            },
+          },
+        },
+      },
+    },
     reference: {
       type: "keyword",
       fields: { text: { type: "text" } },

lib/modules/asset/types/AssetHistoryContent.ts

@@ -21,6 +21,10 @@ export type AssetHistoryEventMetadata = {
   metadata: AssetHistoryMetadata;
 };
 
+export type AssetHistoryEventModelLocales = {
+  name: "modelLocales";
+};
+
 export type AssetHistoryEventLink = {
   name: "link";
   link: {
@@ -39,7 +43,8 @@ export type AssetHistoryEvent =
   | AssetHistoryEventMeasure
   | AssetHistoryEventMetadata
   | AssetHistoryEventLink
-  | AssetHistoryEventUnlink;
+  | AssetHistoryEventUnlink
+  | AssetHistoryEventModelLocales;
 
 /**
  * Asset History document content

lib/modules/measure/types/MeasureDefinition.ts

@@ -1,5 +1,6 @@
 import { SchemaObject } from "ajv";
 import { JSONObject } from "kuzzle-sdk";
+import { LocaleDetails } from "lib/modules/model";
 
 /* *
  * Represents a measure information and localization
@@ -63,6 +64,9 @@ export interface MeasureValuesDetails {
  */
 
 export interface MeasureDefinition {
+  locales?: {
+    [valueName: string]: LocaleDetails;
+  };
   /**
    * Mappings for the measurement values in order to index the fields
    */

lib/modules/model/ModelService.ts

@@ -24,6 +24,7 @@ import { ModelSerializer } from "./ModelSerializer";
 import {
   AssetModelContent,
   DeviceModelContent,
+  LocaleDetails,
   MeasureModelContent,
   MetadataDetails,
   MetadataGroups,
@@ -193,6 +194,7 @@ export class ModelService extends BaseService {
     metadataGroups: MetadataGroups,
     measures: NamedMeasures,
     tooltipModels: TooltipModels,
+    locales: { [valueName: string]: LocaleDetails },
   ): Promise<KDocument<AssetModelContent>> {
     if (Inflector.pascalCase(model) !== model) {
       throw new BadRequestError(`Asset model "${model}" must be PascalCase.`);
@@ -209,6 +211,7 @@ export class ModelService extends BaseService {
     const modelContent: AssetModelContent = {
       asset: {
         defaultMetadata,
+        locales,
         measures,
         metadataDetails,
         metadataGroups,
@@ -369,9 +372,13 @@ export class ModelService extends BaseService {
     valuesMappings: JSONObject,
     validationSchema?: SchemaObject,
     valuesDetails?: MeasureValuesDetails,
+    locales?: {
+      [valueName: string]: LocaleDetails;
+    },
   ): Promise<KDocument<MeasureModelContent>> {
     const modelContent: MeasureModelContent = {
       measure: {
+        locales,
         type,
         valuesDetails,
         valuesMappings,
@@ -689,6 +696,7 @@ export class ModelService extends BaseService {
     metadataGroups: MetadataGroups,
     measures: AssetModelContent["asset"]["measures"],
     tooltipModels: TooltipModels,
+    locales: { [valueName: string]: LocaleDetails },
     request: KuzzleRequest,
   ): Promise<KDocument<AssetModelContent>> {
     if (Inflector.pascalCase(model) !== model) {
@@ -714,6 +722,7 @@ export class ModelService extends BaseService {
     const assetModelContent: AssetModelContent = {
       asset: {
         defaultMetadata,
+        locales,
         measures: measuresUpdated,
         metadataDetails,
         metadataGroups,