kuzzle-device-manager 2.4.0-beta.2 → 2.4.0-beta.20

package/dist/lib/modules/model/types/ModelContent.d.ts

@@ -7,6 +7,87 @@ export interface MeasureModelContent extends KDocumentContent {
         type: string;
     };
 }
+interface MetadataProperty {
+    type: string;
+    strategy?: string;
+    format?: string;
+}
+interface MetadataObject {
+    properties: {
+        [key: string]: MetadataProperty | MetadataObject;
+    };
+}
+export interface MetadataMappings {
+    [key: string]: MetadataProperty | MetadataObject;
+}
+interface LocaleDetails {
+    friendlyName: string;
+    description: string;
+}
+export interface MetadataDetails {
+    [key: string]: {
+        group?: string;
+        locales: {
+            [locale: string]: LocaleDetails;
+        };
+        readOnly?: boolean;
+    };
+}
+interface MetadataGroupLocale {
+    groupFriendlyName: string;
+    description: string;
+}
+export interface MetadataGroups {
+    [groupName: string]: {
+        locales: {
+            [locale: string]: MetadataGroupLocale;
+        };
+    };
+}
+export interface MetadataTooltipContent {
+    category: "metadata";
+    label?: {
+        locales: {
+            [locale: string]: LocaleDetails;
+        };
+    };
+    metadataPath: string;
+    suffix?: string;
+}
+export interface MeasureTooltipContent {
+    category: "measure";
+    label?: {
+        locales: {
+            [locale: string]: LocaleDetails;
+        };
+    };
+    measureSlot: string;
+    measureValuePath: string;
+    suffix?: string;
+}
+export interface StaticTooltipContent {
+    category: "static";
+    label?: {
+        locales: {
+            [locale: string]: LocaleDetails;
+        };
+    };
+    type: StaticTooltipContentType;
+    value: string;
+}
+export declare enum StaticTooltipContentType {
+    link = "link",
+    image = "image",
+    text = "text",
+    title = "title",
+    separator = "separator"
+}
+export interface TooltipModels {
+    [key: string]: {
+        tooltipLabel: string;
+        content: (MetadataTooltipContent | MeasureTooltipContent | StaticTooltipContent)[];
+    };
+}
 export interface AssetModelContent extends KDocumentContent {
     type: "asset";
     engineGroup: string;
@@ -27,7 +108,7 @@ export interface AssetModelContent extends KDocumentContent {
          *   }
          * }
          */
-        metadataMappings: JSONObject;
+        metadataMappings: MetadataMappings;
         /**
          * Default values for metadata.
          *
@@ -37,6 +118,44 @@ export interface AssetModelContent extends KDocumentContent {
          * }
          */
         defaultMetadata: JSONObject;
+        /**
+         * Metadata details
+         * @example
+         * {
+         *   "extTemp": {
+         *     "group": "buildingEnv",
+         *     "locales": {
+         *       "en": {
+         *          "friendlyName": "External temperature",
+         *          "description": "Building external temperature"
+         *       },
+         *       "fr": {
+         *         "friendlyName": "Température extérieure",
+         *         "description": "Température à l'exterieur du bâtiment"
+         *       },
+         *     "readOnly": true,
+         *   }
+         */
+        metadataDetails?: MetadataDetails;
+        /**
+         * Metadata groups list
+         * @example
+         * {
+         *   "buildingEnv": {
+         *     "locales": {
+         *       "en": {
+         *         "groupFriendlyName": "Building environment",
+         *         "description": "The building environment"
+         *       },
+         *       "fr": {
+         *         "groupFriendlyName": "Environnement du bâtiment",
+         *         "description": "L'environnement du bâtiment"
+         *       }
+         *     }
+         *   }
+         * }
+         */
+        metadataGroups?: MetadataGroups;
         /**
          * List of accepted measures for this model
          *
@@ -49,6 +168,53 @@ export interface AssetModelContent extends KDocumentContent {
          * ]
          */
         measures: NamedMeasures;
+        /**
+         * List of tooltip models for this asset model
+         *
+         * @example
+         * [
+         *   "defaultTooltipKey": {
+         *     "tooltipLabel": "Default tooltip model",
+         *     "content": [
+         *       {
+         *         "metadataPath": "geolocation",
+         *         "label": {
+         *           "locales": {
+         *             "en": {
+         *               "description": "",
+         *               "friendlyName": "Container position"
+         *             },
+         *             "fr": {
+         *               "description": "",
+         *               "friendlyName": "Position du conteneur"
+         *             }
+         *           }
+         *         },
+         *         "category": "metadata"
+         *       },
+         *       {
+         *         "measureValuePath": "externalTemperature",
+         *         "measureSlot": "externalTemperature",
+         *         "label": {
+         *           "locales": {
+         *             "en": {
+         *               "description": "",
+         *               "friendlyName": "External temperature"
+         *             },
+         *             "fr": {
+         *               "description": "",
+         *               "friendlyName": "Température extérieure"
+         *             }
+         *           }
+         *         },
+         *         "category": "measure",
+         *         "suffix": "°C"
+         *       }
+         *     ]
+         *   }
+         * ]
+         */
+        tooltipModels?: TooltipModels;
     };
 }
 export interface DeviceModelContent extends KDocumentContent {
@@ -70,7 +236,7 @@ export interface DeviceModelContent extends KDocumentContent {
          *   }
          * }
          */
-        metadataMappings: JSONObject;
+        metadataMappings: MetadataMappings;
         /**
          * Default values for metadata.
          *
@@ -80,6 +246,44 @@ export interface DeviceModelContent extends KDocumentContent {
          * }
          */
         defaultMetadata: JSONObject;
+        /**
+         * Metadata details
+         * @example
+         * {
+         *   "sensorVersion": {
+         *     "group": "sensorSpecs",
+         *     "locales": {
+         *       "en": {
+         *          "friendlyName": "Sensor version",
+         *          "description": "Firmware version of the sensor"
+         *       },
+         *       "fr": {
+         *         "friendlyName": "Version du capteur",
+         *         "description": "Version du micrologiciel du capteur"
+         *       },
+         *     "readOnly": true,
+         *   }
+         */
+        metadataDetails?: MetadataDetails;
+        /**
+         * Metadata groups list
+         * @example
+         * {
+         *   "sensorSpecs": {
+         *     "locales": {
+         *       "en": {
+         *         "groupFriendlyName": "Sensor specifications",
+         *         "description" : "All sensors specifications"
+         *       },
+         *       "fr": {
+         *         "groupFriendlyName": "Spécifications techniques",
+         *         "description": "Toutes les spécifications techniques"
+         *       },
+         *     }
+         *   }
+         * }
+         */
+        metadataGroups?: MetadataGroups;
         /**
          * List of decoded measures for this model
          *
@@ -95,3 +299,4 @@ export interface DeviceModelContent extends KDocumentContent {
     };
 }
 export type ModelContent = MeasureModelContent | AssetModelContent | DeviceModelContent;
+export {};

package/dist/lib/modules/model/types/ModelContent.js

@@ -1,3 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticTooltipContentType = void 0;
+var StaticTooltipContentType;
+(function (StaticTooltipContentType) {
+    StaticTooltipContentType["link"] = "link";
+    StaticTooltipContentType["image"] = "image";
+    StaticTooltipContentType["text"] = "text";
+    StaticTooltipContentType["title"] = "title";
+    StaticTooltipContentType["separator"] = "separator";
+})(StaticTooltipContentType || (exports.StaticTooltipContentType = StaticTooltipContentType = {}));
 //# sourceMappingURL=ModelContent.js.map

package/dist/lib/modules/model/types/ModelContent.js.map

@@ -1 +1 @@
-{"version":3,"file":"ModelContent.js","sourceRoot":"","sources":["../../../../../lib/modules/model/types/ModelContent.ts"],"names":[],"mappings":""}
+{"version":3,"file":"ModelContent.js","sourceRoot":"","sources":["../../../../../lib/modules/model/types/ModelContent.ts"],"names":[],"mappings":";;;AA2FA,IAAY,wBAMX;AAND,WAAY,wBAAwB;IAClC,yCAAa,CAAA;IACb,2CAAe,CAAA;IACf,yCAAa,CAAA;IACb,2CAAe,CAAA;IACf,mDAAuB,CAAA;AACzB,CAAC,EANW,wBAAwB,wCAAxB,wBAAwB,QAMnC"}

package/dist/lib/modules/model/types/ModelDefinition.d.ts

@@ -1,5 +1,6 @@
 import { JSONObject } from "kuzzle-sdk";
 import { Decoder, NamedMeasures } from "../../../modules/decoder";
+import { MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
 /**
  * Define an asset model
  *
@@ -16,6 +17,77 @@ import { Decoder, NamedMeasures } from "../../../modules/decoder";
  *     },
  *     defaultMetadata: {
  *       height: 20
+ *     },
+ *     metadataDetails: {
+ *       "extTemp": {
+ *         "group": "buildingEnv",
+ *         "locales": {
+ *           "en": {
+ *             "friendlyName": "External temperature",
+ *             "description": "Container external temperature"
+ *           },
+ *           "fr": {
+ *             "friendlyName": "Température externe",
+ *             "description": "Température externe du conteneur"
+ *           }
+ *         },
+ *         "readOnly": true,
+ *       }
+ *     },
+ *     metadataGroups: {
+ *       buildingEnv: {
+ *         locales: {
+ *           en: {
+ *             groupFriendlyName: "Building environment",
+ *             description: "The building environment"
+ *           },
+ *           fr: {
+ *             groupFriendlyName: "Environnement du bâtiment",
+ *             description: "L'environnement du bâtiment"
+ *           }
+ *         }
+ *       }
+ *     },
+ *     tooltipModels: {
+ *       "defaultTooltipKey": {
+ *         "tooltipLabel": "Default Tooltip Model",
+ *         "content": [
+ *           {
+ *             "category": "metadata",
+ *             "label": {
+ *               "locales": {
+ *                 "en": {
+ *                   "friendlyName": "Container position",
+ *                   "description": ""
+ *                 },
+ *                 "fr": {
+ *                   "friendlyName": "Position du conteneur",
+ *                   "description": ""
+ *                 }
+ *               }
+ *             },
+ *             "metadataPath": "geolocation"
+ *           },
+ *           {
+ *             "category": "measure",
+ *             "label": {
+ *               "locales": {
+ *                 "en": {
+ *                   "friendlyName": "External temperature",
+ *                   "description": ""
+ *                 },
+ *                 "fr": {
+ *                   "friendlyName": "Température extérieure",
+ *                   "description": ""
+ *                 }
+ *               }
+ *             },
+ *             "measureSlot": "externalTemperature",
+ *             "measureValuePath": "externalTemperature",
+ *             "suffix": "°C"
+ *           }
+ *         ]
+ *       }
  *     }
  *   }
  *
@@ -28,11 +100,23 @@ export type AssetModelDefinition = {
     /**
      * Metadata mappings definition
      */
-    metadataMappings?: JSONObject;
+    metadataMappings?: MetadataMappings;
     /**
      * Default metadata values
      */
     defaultMetadata?: JSONObject;
+    /**
+     * Metadata details including tanslations and group.
+     */
+    metadataDetails?: MetadataDetails;
+    /**
+     * Metadata groups
+     */
+    metadataGroups?: MetadataGroups;
+    /**
+     * Tooltip models
+     */
+    tooltipModels?: TooltipModels;
 };
 /**
  * Define a device model
@@ -42,9 +126,41 @@ export type AssetModelDefinition = {
  *     decoder: new DummyTempPositionDecoder(),
  *     metadataMappings: {
  *       serial: { type: "keyword" },
- *     }
- *   }
- *
+ *     },
+ *     defaultMetadata: {
+ *       company: "Firebird"
+ *     },
+ *     metadataDetails: {
+ *       sensorType: {
+ *         group: "sensorSpecs",
+ *         locales: {
+ *           en: {
+ *             friendlyName: "Sensor type",
+ *             description: "Type of the sensor"
+ *           },
+ *           fr: {
+ *             friendlyName: "Type de traceur",
+ *             description: "Type du traceur"
+ *           }
+ *         },
+ *         readOnly: true,
+ *       }
+ *     },
+ *     metadataGroups: {
+ *      sensorSpecs: {
+ *        locales: {
+ *          en: {
+ *            groupFriendlyName: "Sensor specifications",
+ *            description : "All sensors specifications"
+ *          },
+ *          fr: {
+ *            groupFriendlyName: "Spécifications techniques",
+ *            description: "Toutes les spécifications techniques"
+ *          }
+ *        }
+ *      }
+ *    }
+ *  }
  */
 export type DeviceModelDefinition = {
     /**
@@ -54,9 +170,17 @@ export type DeviceModelDefinition = {
     /**
      * Metadata mappings definition
      */
-    metadataMappings?: JSONObject;
+    metadataMappings?: MetadataMappings;
     /**
      * Default metadata values
      */
     defaultMetadata?: JSONObject;
+    /**
+     * Metadata details including tanslations and group.
+     */
+    metadataDetails?: MetadataDetails;
+    /**
+     * Metadata groups list and details.
+     */
+    metadataGroups?: MetadataGroups;
 };

package/dist/lib/modules/plugin/DeviceManagerEngine.d.ts

@@ -1,9 +1,20 @@
-import { Backend, Plugin } from "kuzzle";
-import { AbstractEngine, ConfigManager } from "kuzzle-plugin-commons";
-import { EngineContent } from "kuzzle-plugin-commons";
-import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
+import { Backend, KDocumentContent, Plugin } from "kuzzle";
+import { AbstractEngine, ConfigManager, EngineContent } from "kuzzle-plugin-commons";
+import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "../model";
 import { DeviceManagerPlugin } from "./DeviceManagerPlugin";
+import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
 import { InternalCollection } from "./types/InternalCollection";
+import { ConflictChunk } from "../model/ModelsConflicts";
+export type TwinType = "asset" | "device";
+export type TwinModelContent = AssetModelContent | DeviceModelContent;
+export interface EngineDocument extends KDocumentContent {
+    type: "engine-device-manager";
+    engine: {
+        group: string;
+        index: string;
+        name: string;
+    };
+}
 export type AskEngineList = {
     name: "ask:device-manager:engine:list";
     payload: {
@@ -16,11 +27,48 @@ export type AskEngineUpdateAll = {
     payload: void;
     result: void;
 };
+export type AskEngineUpdateConflict = {
+    name: "ask:device-manager:engine:doesUpdateConflict";
+    payload: {
+        twin?: {
+            type: TwinType;
+            models: TwinModelContent[];
+        };
+        measuresModels?: MeasureModelContent[];
+    };
+    result: ConflictChunk[];
+};
 export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlugin> {
     config: DeviceManagerConfiguration;
     get app(): Backend;
     constructor(plugin: Plugin, adminConfigManager: ConfigManager, engineConfigManager: ConfigManager);
+    /**
+     * Return conflicts between the new and already present twin models
+     *
+     * @param twinType The target twin type
+     * @param twinModels The already present twin models
+     * @param additionalModels The new or updated twin models
+     * @param measureModels The already present measures models
+     *
+     * @throws If a measure type declared in the twin does not exists
+     * @returns An array of conflict chunk
+     */
+    private doesTwinUpdateConflicts;
+    /**
+     * Return conflicts between the new and already present measure models
+     *
+     * @param measuresModels The already present measure models
+     * @param additionalMeasures The new or updated measure models
+     * @returns An array of ConflictChunk
+     */
+    private doesMeasuresUpdateConflicts;
     updateEngines(): Promise<void>;
+    /**
+     * Search and return every engines in use
+     *
+     * @returns An array of the available engines
+     */
+    getEngines(): Promise<EngineDocument[]>;
     onCreate(index: string, group?: string): Promise<{
         collections: any[];
     }>;
@@ -30,12 +78,100 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
     onDelete(index: string): Promise<{
         collections: InternalCollection[];
     }>;
+    /**
+     * Generate assets mappings and create the assets collection in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the assets collection creation
+     */
     createAssetsCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    /**
+     * Generate assets mappings and create the assets history collection in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the assets history collection creation
+     */
     createAssetsHistoryCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    /**
+     * Create the assets groups collection with the assets groups mappings in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the assets groups collection creation
+     */
     createAssetsGroupsCollection(engineId: string): Promise<InternalCollection>;
-    private getDigitalTwinMappings;
+    /**
+     * Generate devices mappings and create the devices collection in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the devices collection creation
+     */
     createDevicesCollection(engineId: string): Promise<InternalCollection>;
+    /**
+     * Generate measures mappings and create the measures collection in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the measures collection creation
+     */
     createMeasuresCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    /**
+     * Create a collection with custom mappings in an engine
+     *
+     * @param engineIndex The target engine
+     * @param collection The collection name
+     * @param mappings The collection mappings
+     *
+     * @throws If it failed to create the collection
+     */
+    private tryCreateCollection;
+    /**
+     * Generate ES mappings from twin models and theirs associated measures, all fetched from the database
+     *
+     * @param digitalTwinType The target twin type
+     * @param engineGroup The twin engine group
+     * @returns The complete ES mappings produces by merging all the target type twins
+     */
+    private getDigitalTwinMappingsFromDB;
+    /**
+     * Generate ES mappings from twin models and theirs associated measures
+     *
+     * @param digitalTwinType The target twin type
+     * @param models The twin models
+     * @param measureModels The associated measures
+     * @returns The complete ES mappings produces by merging all the target type twins
+     */
+    private getDigitalTwinMappings;
+    /**
+     * Generate ES mappings from measures and theirs associated assets, all fetched via the database
+     *
+     * @param engineGroup The target engine group
+     * @returns The complete ES mappings produced by merging models mappings
+     */
+    private getMeasuresMappingsFromDB;
+    /**
+     * Generate ES mappings from measures and theirs associated assets
+     *
+     * @param models The measures models
+     * @param assetsMappings The assets complete mappings
+     * @returns The complete ES mappings produced by merging models mappings
+     */
     private getMeasuresMappings;
+    /**
+     * Retrieve a certain type of models associated to an engine
+     *
+     * @param engineId The target engine Id
+     * @param type The desired model type
+     * @param engineGroup The target engine group
+     * @returns An array of the generic type provided
+     */
     private getModels;
 }