kuzzle-device-manager-types 3.0.0-next.2 → 3.0.0-next.21

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

@@ -1,5 +1,5 @@
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
-import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
+import { AssetModelContent, DeviceModelContent, GroupAffinity, GroupModelContent, LocaleDetails, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
 import { SchemaObject } from "ajv";
 import { MeasureValuesDetails } from "../../measure/types/MeasureDefinition";
 interface ModelsControllerRequest {
@@ -16,6 +16,11 @@ export interface ApiModelGetDeviceRequest extends ModelsControllerRequest {
     model: string;
 }
 export type ApiModelGetDeviceResult = KDocument<DeviceModelContent>;
+export interface ApiModelGetGroupRequest extends ModelsControllerRequest {
+    action: "getGroup";
+    model: string;
+}
+export type ApiModelGetGroupResult = KDocument<GroupModelContent>;
 export interface ApiModelGetMeasureRequest extends ModelsControllerRequest {
     action: "getMeasure";
     type: string;
@@ -32,6 +37,9 @@ export interface ApiModelWriteAssetRequest extends ModelsControllerRequest {
         defaultValues?: JSONObject;
         measures?: AssetModelContent["asset"]["measures"];
         tooltipModels?: TooltipModels;
+        locales?: {
+            [valueName: string]: LocaleDetails;
+        };
     };
 }
 export type ApiModelWriteAssetResult = KDocument<AssetModelContent>;
@@ -47,10 +55,26 @@ export interface ApiModelWriteDeviceRequest extends ModelsControllerRequest {
     };
 }
 export type ApiModelWriteDeviceResult = KDocument<DeviceModelContent>;
+export interface ApiModelWriteGroupRequest extends ModelsControllerRequest {
+    action: "writeGroup";
+    body: {
+        affinity: GroupAffinity;
+        engineGroup: string;
+        model: string;
+        metadataDetails?: MetadataDetails;
+        metadataGroups?: MetadataGroups;
+        metadataMappings?: MetadataMappings;
+        defaultValues?: JSONObject;
+    };
+}
+export type ApiModelWriteGroupResult = KDocument<GroupModelContent>;
 export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
     action: "writeMeasure";
     body: {
         type: string;
+        locales?: {
+            [valueName: string]: LocaleDetails;
+        };
         valuesMappings: JSONObject;
         validationSchema?: SchemaObject;
         valuesDetails?: MeasureValuesDetails;
@@ -68,6 +92,9 @@ export interface ApiModelUpdateAssetRequest extends ModelsControllerRequest {
         defaultValues?: JSONObject;
         measures?: AssetModelContent["asset"]["measures"];
         tooltipModels?: TooltipModels;
+        locales?: {
+            [valueName: string]: LocaleDetails;
+        };
     };
 }
 export type ApiModelUpdateAssetResult = KDocument<AssetModelContent>;
@@ -81,6 +108,11 @@ export interface ApiModelDeleteDeviceRequest extends ModelsControllerRequest {
     _id: string;
 }
 export type ApiModelDeleteDeviceResult = void;
+export interface ApiModelDeleteGroupRequest extends ModelsControllerRequest {
+    action: "deleteGroup";
+    _id: string;
+}
+export type ApiModelDeleteGroupResult = void;
 export interface ApiModelDeleteMeasureRequest extends ModelsControllerRequest {
     action: "deleteMeasure";
     _id: string;
@@ -101,6 +133,14 @@ export type ApiModelListDevicesResult = {
     models: KDocument<DeviceModelContent>[];
     total: number;
 };
+export interface ApiModelListGroupsRequest extends ModelsControllerRequest {
+    action: "listGroups";
+    engineGroup: string;
+}
+export type ApiModelListGroupsResult = {
+    models: KDocument<GroupModelContent>[];
+    total: number;
+};
 export interface ApiModelListMeasuresRequest extends ModelsControllerRequest {
     action: "listMeasures";
 }
@@ -125,6 +165,15 @@ export interface ApiModelSearchDevicesRequest extends ModelsControllerRequest {
     body?: JSONObject;
 }
 export type ApiModelSearchDevicesResult = SearchResult<KHit<DeviceModelContent>>;
+export interface ApiModelSearchGroupsRequest extends ModelsControllerRequest {
+    action: "searchGroups";
+    engineGroup: string;
+    from?: number;
+    size?: number;
+    scrollTTL?: string;
+    body?: JSONObject;
+}
+export type ApiModelSearchGroupsResult = SearchResult<KHit<GroupModelContent>>;
 export interface ApiModelSearchMeasuresRequest extends ModelsControllerRequest {
     action: "searchMeasures";
     from?: number;

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

@@ -5,6 +5,9 @@ export interface MeasureModelContent extends KDocumentContent {
     type: "measure";
     measure: MeasureDefinition & {
         type: string;
+        locales?: {
+            [valueName: string]: LocaleDetails;
+        };
     };
 }
 export interface MetadataProperty {
@@ -20,13 +23,31 @@ export interface MetadataObject {
 export interface MetadataMappings {
     [key: string]: MetadataProperty | MetadataObject;
 }
+export interface GroupAffinity {
+    /**
+     * Type of elements accepted in the group
+     */
+    type: Array<"assets" | "devices">;
+    /**
+     * Models accepted in the group
+     */
+    models: {
+        assets?: string[];
+        devices?: string[];
+    };
+    /**
+     * Weather the affinities are a strict restriction or not
+     */
+    strict: boolean;
+}
 export interface LocaleDetails {
     friendlyName: string;
     description: string;
 }
 export interface BaseEditorHint {
     readOnly?: boolean;
-    type: EditorHintEnum;
+    isModal?: boolean;
+    type: EditorHintEnum | string;
 }
 export declare enum EditorHintEnum {
     BASE = "base",
@@ -264,6 +285,12 @@ export interface AssetModelContent extends KDocumentContent {
          * ]
          */
         tooltipModels?: TooltipModels;
+        /**
+         * Translations specific to the model
+         */
+        locales?: {
+            [locale: string]: LocaleDetails;
+        };
     };
 }
 export interface DeviceModelContent extends KDocumentContent {
@@ -355,4 +382,132 @@ export interface DeviceModelContent extends KDocumentContent {
         measures: NamedMeasures;
     };
 }
-export type ModelContent = MeasureModelContent | AssetModelContent | DeviceModelContent;
+export interface GroupModelContent extends KDocumentContent {
+    type: "group";
+    engineGroup: string;
+    group: {
+        /**
+         * Name of the model
+         */
+        model: string;
+        /**
+         * Group types and model affinities
+         */
+        affinity: GroupAffinity;
+        /**
+         * Metadata mappings.
+         *
+         * @example
+         * {
+         *   "company": {
+         *     "properties": {
+         *        "name": { "type": "keyword" },
+         *      }
+         *   }
+         * }
+         */
+        metadataMappings: MetadataMappings;
+        /**
+         * Default values for metadata.
+         *
+         * @example
+         * {
+         *    "company.name": "Firebird"
+         * }
+         */
+        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"
+         *       },
+         *     },
+         *     "editorHint": {
+         *       "readOnly": true,
+         *       "type": EditorHintEnum.OPTION_SELECTOR,
+         *       "values": ["red", "blue"],
+         *       "customValueAllowed": 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 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 type ModelContent = MeasureModelContent | AssetModelContent | DeviceModelContent | GroupModelContent;

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

@@ -1,6 +1,6 @@
 import { JSONObject } from "kuzzle-sdk";
 import { Decoder, NamedMeasures } from "../../../modules/decoder";
-import { MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
+import { GroupAffinity, LocaleDetails, MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from "./ModelContent";
 /**
  * Define an asset model
  *
@@ -94,7 +94,17 @@ import { MetadataDetails, MetadataGroups, MetadataMappings, TooltipModels } from
  *           }
  *         ]
  *       }
- *     }
+ *     },
+ *     locales: {
+ *       en: {
+ *         friendlyName: 'Container (translation by model)',
+ *         description: 'Containerized container',
+ *       },
+ *       fr: {
+ *         friendlyName: 'Conteneur (traduit par model)',
+ *         description: 'Conteneur conteneurisé',
+ *       },
+ *     },
  *   }
  *
  */
@@ -123,6 +133,9 @@ export type AssetModelDefinition = {
      * Tooltip models
      */
     tooltipModels?: TooltipModels;
+    locales?: {
+        [valueName: string]: LocaleDetails;
+    };
 };
 /**
  * Define a device model
@@ -196,3 +209,98 @@ export type DeviceModelDefinition = {
      */
     metadataGroups?: MetadataGroups;
 };
+/**
+ * Define a group model
+ *
+ * @example
+ *   {
+ *     metadataMappings: {
+ *       position: { type: "geo_point" },
+ *     },
+ *     defaultMetadata: {
+ *       position: {
+ *          lat: 41.12,
+ *          lon: -71.34
+ *       }
+ *     },
+ *     metadataDetails: {
+ *       "position": {
+ *         "group": "geolocation",
+ *         "locales": {
+ *           "en": {
+ *             "friendlyName": "Parking position",
+ *             "description": "The coordinates of the parking"
+ *           },
+ *           "fr": {
+ *             "friendlyName": "Position du parking",
+ *             "description": "Les coordonnées GPS du parking"
+ *           }
+ *         },
+ *       },
+ *     },
+ *     metadataGroups: {
+ *       geolocation: {
+ *         locales: {
+ *           en: {
+ *             groupFriendlyName: "Parking geolocation",
+ *             description: "The parking geolocation"
+ *           },
+ *           fr: {
+ *             groupFriendlyName: "Localisation du parking",
+ *             description: "La localisation du parking"
+ *           }
+ *         }
+ *       }
+ *     },
+ *     tooltipModels: {
+ *       "defaultTooltipKey": {
+ *         "tooltipLabel": "Default Tooltip Model",
+ *         "content": [
+ *           {
+ *             "category": "metadata",
+ *             "label": {
+ *               "locales": {
+ *                 "en": {
+ *                   "friendlyName": "Parking position",
+ *                   "description": ""
+ *                 },
+ *                 "fr": {
+ *                   "friendlyName": "Position du parking",
+ *                   "description": ""
+ *                 }
+ *               }
+ *             },
+ *             "metadataPath": "position"
+ *           },
+ *         ]
+ *       }
+ *     }
+ *   }
+ *
+ */
+export type GroupModelDefinition = {
+    /**
+     * Metadata mappings definition
+     */
+    affinity: GroupAffinity;
+    /**
+     * Metadata mappings definition
+     */
+    metadataMappings?: MetadataMappings;
+    /**
+     * Default metadata values
+     */
+    defaultMetadata?: JSONObject;
+    /**
+     * Metadata details including tanslations and group.
+     */
+    metadataDetails?: MetadataDetails;
+    /**
+     * Metadata groups
+     */
+    metadataGroups?: MetadataGroups;
+    /**
+     * Tooltip models
+     */
+    tooltipModels?: TooltipModels;
+};

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

@@ -1,4 +1,4 @@
-import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "./ModelContent";
+import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelContent } from "./ModelContent";
 export type AskModelAssetGet = {
     name: "ask:device-manager:model:asset:get";
     payload: {
@@ -21,3 +21,10 @@ export type AskModelMeasureGet = {
     };
     result: MeasureModelContent;
 };
+export type AskModelGroupGet = {
+    name: "ask:device-manager:model:group:get";
+    payload: {
+        model: string;
+    };
+    result: GroupModelContent;
+};

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

@@ -1,6 +1,6 @@
 import { Backend, KDocumentContent, Plugin } from "kuzzle";
 import { AbstractEngine, ConfigManager, EngineContent } from "kuzzle-plugin-commons";
-import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "../model";
+import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelContent } from "../model";
 import { DeviceManagerPlugin } from "./DeviceManagerPlugin";
 import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
 import { InternalCollection } from "./types/InternalCollection";
@@ -18,7 +18,7 @@ export interface EngineDocument extends KDocumentContent {
 export type AskEngineList = {
     name: "ask:device-manager:engine:list";
     payload: {
-        group: string | null;
+        group?: string;
     };
     result: EngineContent[];
 };
@@ -35,13 +35,14 @@ export type AskEngineUpdateConflict = {
             models: TwinModelContent[];
         };
         measuresModels?: MeasureModelContent[];
+        groupModels?: GroupModelContent[];
     };
     result: ConflictChunk[];
 };
 export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlugin> {
     config: DeviceManagerConfiguration;
     get app(): Backend;
-    constructor(plugin: Plugin, adminConfigManager: ConfigManager, engineConfigManager: ConfigManager);
+    constructor(plugin: Plugin, platformConfigManager: ConfigManager, engineConfigManager: ConfigManager);
     /**
      * Return conflicts between the new and already present twin models
      *
@@ -54,6 +55,14 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * @returns An array of conflict chunk
      */
     private doesTwinUpdateConflicts;
+    /**
+     * Return conflicts between the new and already present group models
+     *
+     * @param groupModels The already present group models
+     * @param additionalGroups The new or updated group models
+     * @returns An array of ConflictChunk
+     */
+    private doesGroupsUpdateConflicts;
     /**
      * Return conflicts between the new and already present measure models
      *
@@ -98,14 +107,14 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      */
     createAssetsHistoryCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
     /**
-     * Create the assets groups collection with the assets groups mappings in the engine
+     * Create the groups collection with the 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
+     * @throws If it failed during the groups collection creation
      */
-    createAssetsGroupsCollection(engineId: string): Promise<InternalCollection>;
+    createGroupsCollection(engineId: string): Promise<InternalCollection>;
     /**
      * Generate devices mappings and create the devices collection in the engine
      *
@@ -115,6 +124,15 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * @throws If it failed during the devices collection creation
      */
     createDevicesCollection(engineId: string): Promise<InternalCollection>;
+    /**
+     * 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
+     */
+    createPlatformDevicesCollection(): Promise<InternalCollection>;
     /**
      * Generate measures mappings and create the measures collection in the engine
      *
@@ -166,6 +184,7 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * @returns The complete ES mappings produced by merging models mappings
      */
     private getMeasuresMappings;
+    getAssetGroupsMappingFromDB(): Promise<any>;
     /**
      * Retrieve a certain type of models associated to an engine
      *
@@ -175,4 +194,11 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * @returns An array of the generic type provided
      */
     private getModels;
+    /**
+     * Detach all devices of an index in the platform index
+     *
+     * @param engineId The target engine Id
+     * @returns {any}
+     */
+    private detachDevicesFromPlatformIndex;
 }

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

@@ -1,21 +1,23 @@
 import { Plugin, PluginContext } from "kuzzle";
 import { JSONObject } from "kuzzle-sdk";
 import { MeasureDefinition } from "../measure";
-import { AssetModelDefinition, DeviceModelDefinition } from "../model";
+import { DecodersRegister } from "../decoder";
+import { AssetModelDefinition, DeviceModelDefinition, GroupModelDefinition, ModelsRegister } from "../model";
 import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
 export declare class DeviceManagerPlugin extends Plugin {
     config: DeviceManagerConfiguration;
     private deviceManagerEngine;
-    private adminConfigManager;
+    private platformConfigManager;
     private engineConfigManager;
     private engineController;
     private assetModule;
     private deviceModule;
+    private groupModule;
     private decoderModule;
     private measureModule;
     private modelModule;
-    private modelsRegister;
-    private decodersRegister;
+    readonly modelsRegister: ModelsRegister;
+    readonly decodersRegister: DecodersRegister;
     private get sdk();
     get models(): {
         /**
@@ -177,6 +179,59 @@ export declare class DeviceManagerPlugin extends Plugin {
          * ```
          */
         registerDevice: (model: string, definition: DeviceModelDefinition) => void;
+        /**
+         * Register a group.
+         *
+         * @param model Name of the group model
+         * @param definition Object containing the group model definition, including:
+         *                   - metadataMappings: Metadata mappings definition
+         *                   - defaultMetadata: Default metadata values
+         *                   - metadataDetails: Localizations, detailed metadata descriptions and definition
+         *                   - metadataGroups: Groups for organizing metadata, with localizations
+         *
+         * @example
+         * ```
+         * deviceManager.models.registerGroup(
+         *   "Parking",
+         *   {
+         *     metadataMappings: {
+         *       geolocation: { type: "geo_point" },
+         *     },
+         *     defaultMetadata: {
+         *
+         *     },
+         *     metadataDetails: {
+         *       geolocation: {
+         *         group: "access",
+         *         locales: {
+         *           en: {
+         *             friendlyName: "Parking location",
+         *             description: "GPS position of the parking"
+         *           },
+         *           fr: {
+         *             friendlyName: "Emplacement du parking",
+         *             description: "Position GPS du parking"
+         *           }
+         *         }
+         *       }
+         *     },
+         *     metadataGroups: {
+         *       access: {
+         *         locales: {
+         *           en: {
+         *             groupFriendlyName: "Parking access info"
+         *           },
+         *           fr: {
+         *             groupFriendlyName: "Information d'accès au parking"
+         *           }
+         *         }
+         *       }
+         *     }
+         *   }
+         * );
+         * ```
+         */
+        registerGroup: (engineGroup: string, model: string, definition: GroupModelDefinition) => void;
         /**
          * Register a new measure
          *
@@ -200,7 +255,7 @@ export declare class DeviceManagerPlugin extends Plugin {
      */
     init(config: JSONObject, context: PluginContext): Promise<void>;
     /**
-     * Initialize the administration index of the plugin
+     * Initialize the platform index of the plugin
      */
     private initDatabase;
     /**

package/dist/lib/modules/plugin/types/DeviceManagerConfiguration.d.ts

@@ -16,13 +16,13 @@ export type DeviceManagerConfiguration = {
         autoUpdate: true;
     };
     /**
-     * Administration index name
+     * Platform index name
      */
-    adminIndex: string;
+    platformIndex: string;
     /**
-     * Administration collections mappings (in admin index)
+     * Collection mappings for the platform index
      */
-    adminCollections: {
+    platformCollections: {
         config: {
             name: string;
             mappings: JSONObject;
@@ -45,20 +45,21 @@ export type DeviceManagerConfiguration = {
             mappings: JSONObject;
             settings?: JSONObject;
         };
-        asset: {
+        assets: {
             name: string;
             mappings: CollectionMappings;
             settings?: JSONObject;
         };
-        assetGroups: {
+        groups: {
             name: string;
+            mappings: CollectionMappings;
             settings?: JSONObject;
         };
         assetHistory: {
             name: string;
             settings?: JSONObject;
         };
-        device: {
+        devices: {
             name: string;
             mappings: CollectionMappings;
             settings?: JSONObject;
@@ -66,6 +67,7 @@ export type DeviceManagerConfiguration = {
         measures: {
             name: string;
             settings?: JSONObject;
+            mappings: CollectionMappings;
         };
     };
 };