kuzzle-device-manager-types 2.11.0-dev.1 → 3.0.0-3-dev.1

package/dist/lib/modules/device/types/DeviceApi.d.ts

@@ -59,14 +59,40 @@ export interface ApiDeviceSearchRequest extends DevicesControllerRequest {
     body: JSONObject;
 }
 export type ApiDeviceSearchResult = SearchResult<KHit<DeviceContent>>;
-export interface ApiDeviceUnlinkAssetRequest extends DevicesControllerRequest {
-    action: "unlinkAsset";
+export interface ApiDeviceUnlinkAssetsRequest extends DevicesControllerRequest {
+    action: "unlinkAssets";
     _id: string;
     strict?: boolean;
     refresh?: string;
+    body: {
+        /**
+         * This options allows to unlink all the measures of the device
+         */
+        allMeasures?: boolean;
+        /**
+         * Names of the measure slots of the device to unlink.
+         *
+         * string[]
+         *
+         * @example
+         *
+         * ['externalTemperature','position']
+         */
+        measureSlots?: string[];
+        /**
+         * Ids of the assets to unlink.
+         *
+         * string[]
+         *
+         * @example
+         *
+         * ['First-asset','Second-asset']
+         */
+        assets?: string[];
+    };
 }
-export type ApiDeviceUnlinkAssetResult = {
-    asset: KDocument<AssetContent>;
+export type ApiDeviceUnlinkAssetsResult = {
+    assets: KDocument<AssetContent>[];
     device: KDocument<DeviceContent>;
 };
 export interface ApiDeviceAttachEngineRequest extends DevicesControllerRequest {
@@ -81,48 +107,50 @@ export interface ApiDeviceDetachEngineRequest extends DevicesControllerRequest {
     refresh?: string;
 }
 export type ApiDeviceDetachEngineResult = void;
-export interface ApiDeviceLinkAssetRequest extends DevicesControllerRequest {
-    action: "linkAsset";
+export interface ApiDeviceLinkAssetsRequest extends DevicesControllerRequest {
+    action: "linkAssets";
     _id: string;
     refresh?: string;
-    assetId: string;
-    /**
-     * This option allows to not specify the names of all the measures that should
-     * be linked to the asset.
-     *
-     * The algorithm will go through all the measures names provided by the device
-     * and add the one who are present with the same name in the asset.
-     *
-     * It will not add the measure if:
-     *   - it has been specified in the link request
-     *   - it was already present in the asset
-     *
-     * @example
-     *   if the device provide a measure of type "temperature" with the name "temp"
-     *   if the asset has declared a measure of type "temperature" with the name "temp"
-     *   then the measure will be automatically added in the link and will later be propagated to the asset
-     */
-    implicitMeasuresLinking?: boolean;
-    body?: {
-        /**
-         * Names of the linked measures.
-         *
-         * Array<{ asset: string, device: string }>
-         *
-         * @example
-         *
-         * [
-         *   { asset: "externalTemperature", device: "temperature" }
-         * ]
-         */
-        measureNames?: Array<{
-            asset: string;
-            device: string;
+    body: {
+        linkedMeasures: Array<{
+            assetId: string;
+            /**
+             * This option allows to not specify the names of all the measures that should
+             * be linked to the asset.
+             *
+             * The algorithm will go through all the measures names provided by the device
+             * and add the one who are present with the same name in the asset.
+             *
+             * It will not add the measure if:
+             *   - it has been specified in the link request
+             *   - it was already present in the asset
+             *
+             * @example
+             *   if the device provide a measure of type "temperature" with the name "temp"
+             *   if the asset has declared a measure of type "temperature" with the name "temp"
+             *   then the measure will be automatically added in the link and will later be propagated to the asset
+             */
+            implicitMeasuresLinking?: boolean;
+            /**
+             * Names of the linked measures.
+             *
+             * Array<{ asset: string, device: string }>
+             *
+             * @example
+             *
+             * [
+             *   { asset: "externalTemperature", device: "temperature" }
+             * ]
+             */
+            measureSlots?: Array<{
+                asset: string;
+                device: string;
+            }>;
         }>;
     };
 }
-export type ApiDeviceLinkAssetResult = {
-    asset: KDocument<AssetContent>;
+export type ApiDeviceLinkAssetsResult = {
+    assets: KDocument<AssetContent>[];
     device: KDocument<DeviceContent>;
 };
 export interface ApiDeviceGetMeasuresRequest extends DevicesControllerRequest {

package/dist/lib/modules/device/types/DeviceContent.d.ts

@@ -1,14 +1,65 @@
-import { JSONObject } from "kuzzle-sdk";
+import { JSONObject, KDocumentContent } from "kuzzle-sdk";
 import { DigitalTwinContent, Metadata } from "../../shared";
 /**
  * Device document content
  */
-export interface DeviceContent<TMeasures extends JSONObject = any, TMetadata extends Metadata = any> extends DigitalTwinContent<TMeasures, TMetadata> {
+export interface DeviceContent<TMetadata extends Metadata = any> extends DigitalTwinContent<TMetadata> {
     /**
-     * Linked asset unique identifier
+     * Link with attached assets
      */
-    assetId: string | null;
+    linkedMeasures: Array<{
+        /**
+         * Asset ID
+         */
+        assetId: string;
+        /**
+         * Slots of the linked measures
+         *
+         * Array<{ asset: string, device: string, type: string }>
+         *
+         * @example
+         *
+         * [
+         *   { asset: "externalTemperature", device: "temperature", }
+         * ]
+         */
+        measureSlots: Array<{
+            asset: string;
+            device: string;
+        }>;
+    }>;
     /**
      */
-    engineId: string;
+    engineId: string | null;
+    /**
+     * Path's of device's groups
+     */
+    groups: Array<{
+        path: string;
+        date: number;
+    }>;
+}
+/**
+ * Platform index Device document content
+ */
+interface DeviceProvisioningContentFields extends Pick<DeviceContent, "model" | "reference" | "engineId" | "measureSlots"> {
+    /**
+     * Date of provisioning of the device on the platform
+     */
+    provisionedAt: number;
+    /**
+     * Date of last measure from the device
+     */
+    lastMeasuredAt: number | null;
+    /**
+     * An array containing the 5 last measures from the device
+     */
+    lastMeasures: Array<{
+        measureName: string;
+        values: JSONObject;
+        measuredAt: number;
+        type: string;
+    }>;
 }
+export type DeviceProvisioningContent = DeviceProvisioningContentFields & KDocumentContent;
+export {};

package/dist/lib/modules/device/types/DeviceEvents.d.ts

@@ -1,8 +1,8 @@
 import { User } from "kuzzle";
 import { KDocument } from "kuzzle-sdk";
-import { Metadata } from "../../../modules/shared";
+import { DeviceModelContent } from "../../model";
+import { Metadata } from "../../shared";
 import { DeviceContent } from "./DeviceContent";
-import { ApiDeviceLinkAssetRequest } from "./DeviceApi";
 export type EventDeviceUpdateBefore = {
     name: "device-manager:device:update:before";
     args: [{
@@ -17,28 +17,6 @@ export type EventDeviceUpdateAfter = {
         metadata: Metadata;
     }];
 };
-/**
- * @internal
- */
-export type AskDeviceLinkAsset = {
-    name: "ask:device-manager:device:link-asset";
-    payload: {
-        engineId: string;
-        assetId: string;
-        deviceId: string;
-        user: User;
-        measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"];
-    };
-    result: void;
-};
-export type AskDeviceUnlinkAsset = {
-    name: "ask:device-manager:device:unlink-asset";
-    payload: {
-        deviceId: string;
-        user: User;
-    };
-    result: void;
-};
 export type AskDeviceDetachEngine = {
     name: "ask:device-manager:device:detach-engine";
     payload: {
@@ -56,3 +34,10 @@ export type AskDeviceAttachEngine = {
     };
     result: void;
 };
+export type AskDeviceRefreshModel = {
+    name: "ask:device-manager:device:refresh-model";
+    payload: {
+        deviceModel: DeviceModelContent;
+    };
+    result: void;
+};

package/dist/lib/modules/group/GroupsController.d.ts

@@ -0,0 +1,37 @@
+import { ControllerDefinition, KuzzleRequest } from "kuzzle";
+import { DeviceManagerPlugin } from "../plugin";
+import { ApiGroupAddAssetsResult, ApiGroupAddDevicesResult, ApiGroupCreateResult, ApiGroupDeleteResult, ApiGroupGetResult, ApiGroupListItemsResult, ApiGroupMCreateResult, ApiGroupMUpdateResult, ApiGroupMUpsertResult, ApiGroupRemoveAssetsResult, ApiGroupRemoveDevicesResult, ApiGroupSearchResult, ApiGroupUpdateResult, ApiGroupUpsertResult, GroupsBodyRequest } from "./types/GroupsApi";
+import { GroupsService } from "./GroupsService";
+import { KuzzleLogger } from "kuzzle-logger";
+export declare class GroupsController {
+    private plugin;
+    private groupsService;
+    definition: ControllerDefinition;
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, groupsService: GroupsService, logger: KuzzleLogger);
+    private get sdk();
+    private get as();
+    /**
+     * Check that the path property is valid, and closest parent exists.
+     * @param {string} engineId Engine ID
+     * @param {string} path The path of a group
+     * @throws {BadRequestError} If the path is not a string or if the path is not valid.
+     * @returns {void}
+     */
+    checkPath(engineId: string, path: GroupsBodyRequest["path"], groupId?: string): Promise<void>;
+    checkGroupName(engineId: string, name: GroupsBodyRequest["name"], assetId?: string): Promise<void>;
+    create(request: KuzzleRequest): Promise<ApiGroupCreateResult>;
+    get(request: KuzzleRequest): Promise<ApiGroupGetResult>;
+    upsert(request: KuzzleRequest): Promise<ApiGroupUpsertResult>;
+    update(request: KuzzleRequest): Promise<ApiGroupUpdateResult>;
+    delete(request: KuzzleRequest): Promise<ApiGroupDeleteResult>;
+    search(request: KuzzleRequest): Promise<ApiGroupSearchResult>;
+    listItems(request: KuzzleRequest): Promise<ApiGroupListItemsResult>;
+    addAssets(request: KuzzleRequest): Promise<ApiGroupAddAssetsResult>;
+    removeAssets(request: KuzzleRequest): Promise<ApiGroupRemoveAssetsResult>;
+    addDevices(request: KuzzleRequest): Promise<ApiGroupAddDevicesResult>;
+    removeDevices(request: KuzzleRequest): Promise<ApiGroupRemoveDevicesResult>;
+    mCreate(request: KuzzleRequest): Promise<ApiGroupMCreateResult>;
+    mUpdate(request: KuzzleRequest): Promise<ApiGroupMUpdateResult>;
+    mUpsert(request: KuzzleRequest): Promise<ApiGroupMUpsertResult>;
+}

package/dist/lib/modules/group/GroupsModule.d.ts

@@ -0,0 +1,10 @@
+import { DeviceManagerPlugin } from "../plugin";
+import { Module } from "../shared/Module";
+import { KuzzleLogger } from "kuzzle-logger";
+export declare class GroupsModule extends Module {
+    private groupsController;
+    private groupsService;
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin);
+    init(): Promise<void>;
+}

package/dist/lib/modules/group/GroupsService.d.ts

@@ -0,0 +1,118 @@
+import { JSONObject, KDocument } from "kuzzle-sdk";
+import { DeviceManagerPlugin } from "../plugin";
+import { BaseService, Metadata, SearchParams } from "../shared";
+import { KuzzleRequest } from "kuzzle";
+import { AssetContent } from "../asset/types/AssetContent";
+import { ApiGroupMCreateResult, ApiGroupMUpdateResult, ApiGroupMUpsertResult, GroupContent } from "./exports";
+import { DeviceContent } from "../device";
+import { KuzzleLogger } from "kuzzle-logger";
+export declare class GroupsService extends BaseService {
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
+    create(_id: string, engineId: string, metadata: JSONObject, model: string, name: string, path: string, request: KuzzleRequest): Promise<KDocument<GroupContent>>;
+    get(engineId: string, _id: string, request: KuzzleRequest): Promise<import("kuzzle").KDocument<GroupContent>>;
+    update(request: KuzzleRequest, _id: string, engineId: string, name?: string, path?: string, metadata?: Metadata): Promise<import("kuzzle").KDocument<GroupContent>>;
+    delete(_id: string, engineId: string, request: KuzzleRequest): Promise<{
+        _id: string;
+    }>;
+    search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<import("kuzzle").SearchResult<import("kuzzle").KHit<GroupContent>>>;
+    listItems(engineId: string, _id: string, includeChildren: boolean, options: {
+        from?: number;
+        size?: number;
+    }, request: KuzzleRequest): Promise<{
+        assets: {
+            hits: import("kuzzle").KHit<AssetContent<any>>[];
+            total: number;
+        };
+        devices: {
+            hits: import("kuzzle").KHit<DeviceContent<any>>[];
+            total: number;
+        };
+    }>;
+    addAssets(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
+        group: import("kuzzle").KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: import("kuzzle").JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                body: import("kuzzle").JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    removeAssets(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
+        group: import("kuzzle").KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: import("kuzzle").JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                body: import("kuzzle").JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    addDevices(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
+        group: import("kuzzle").KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: import("kuzzle").JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                body: import("kuzzle").JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    removeDevices(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
+        group: import("kuzzle").KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: import("kuzzle").JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                body: import("kuzzle").JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    mCreate(engineId: string, groups: Array<{
+        _id: string;
+        metadata: Metadata;
+        model: string;
+        name: string;
+        path: string;
+    }>): Promise<ApiGroupMCreateResult>;
+    mUpdate(engineId: string, groups: Array<{
+        _id: string;
+        metadata: Metadata;
+        model: string;
+        name: string;
+        path: string;
+    }>, request: KuzzleRequest): Promise<ApiGroupMUpdateResult>;
+    mUpsert(engineId: string, groups: Array<{
+        _id: string;
+        metadata: Metadata;
+        model: string;
+        name: string;
+        path: string;
+    }>, request: KuzzleRequest): Promise<ApiGroupMUpsertResult>;
+    private _update;
+}

package/dist/lib/modules/group/collections/groupsMappings.d.ts

@@ -0,0 +1,2 @@
+import { CollectionMappings } from "kuzzle";
+export declare const groupsMappings: CollectionMappings;

package/dist/lib/modules/group/exports.d.ts

@@ -0,0 +1,5 @@
+export * from "./types/GroupContent";
+export * from "./types/GroupsApi";
+export * from "./roles/RoleGroupsAdmin";
+export * from "./roles/RoleGroupsReader";
+export * from "./collections/groupsMappings";

package/dist/lib/modules/group/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./collections/groupsMappings";
+export * from "./GroupsModule";
+export * from "./roles/RoleGroupsAdmin";
+export * from "./roles/RoleGroupsReader";

package/dist/lib/modules/{asset/roles/RoleAssetsGroupsAdmin.d.ts → group/roles/RoleGroupsAdmin.d.ts}

@@ -1,12 +1,12 @@
 import { KuzzleRole } from "../../shared/types/KuzzleRole";
 /**
- * This role allows to manage assets and their models.
+ * This role allows to manage groups and their models.
  *
  * It's a tenant role.
  *
  * @example
  *
-    "device-manager/assets": {
+    "device-manager/groups": {
       actions: {
         "*": true,
       },
@@ -21,4 +21,4 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
       },
     },
  */
-export declare const RoleAssetsGroupsAdmin: KuzzleRole;
+export declare const RoleGroupsAdmin: KuzzleRole;

package/dist/lib/modules/{asset/roles/RoleAssetsGroupsReader.d.ts → group/roles/RoleGroupsReader.d.ts}

@@ -1,12 +1,12 @@
 import { KuzzleRole } from "../../shared/types/KuzzleRole";
 /**
- * This role allows to manage assets and their models.
+ * This role allows to manage groups and their models.
  *
  * It's a tenant role.
  *
  * @example
  *
-    "device-manager/assets": {
+    "device-manager/groups": {
       actions: {
         "*": true,
       },
@@ -21,4 +21,4 @@ import { KuzzleRole } from "../../shared/types/KuzzleRole";
       },
     },
  */
-export declare const RoleAssetsGroupsReader: KuzzleRole;
+export declare const RoleGroupsReader: KuzzleRole;

package/dist/lib/modules/group/types/GroupContent.d.ts

@@ -0,0 +1,10 @@
+import { KDocumentContent } from "kuzzle-sdk";
+import { Metadata } from "lib/modules/shared";
+export interface GroupsBody<TMetadata extends Metadata = Metadata> extends KDocumentContent {
+    name: string;
+    model?: string | null;
+    path: string;
+    lastUpdate: number;
+    metadata?: TMetadata;
+}
+export type GroupContent<TMetadata extends Metadata = any> = GroupsBody<TMetadata>;

package/dist/lib/modules/group/types/GroupsApi.d.ts

@@ -0,0 +1,141 @@
+import { JSONObject, KDocument, KHit, SearchResult, mCreateResponse, mUpdateResponse } from "kuzzle-sdk";
+import { GroupsBody, GroupContent } from "./GroupContent";
+import { DeviceContent } from "lib/modules/device";
+import { AssetContent } from "lib/modules/asset";
+type GroupsRequest = Omit<GroupsBody, "lastUpdate">;
+export type GroupsBodyRequest = Partial<GroupsRequest>;
+export type UpdateLinkResponse = mUpdateResponse & {
+    group: KDocument<GroupContent>;
+};
+interface GroupControllerRequest {
+    controller: "device-manager/groups";
+    engineId: string;
+}
+export interface ApiGroupCreateRequest extends GroupControllerRequest {
+    action: "create";
+    _id?: string;
+    body: GroupsBodyRequest;
+}
+export type ApiGroupCreateResult = KDocument<GroupContent>;
+export interface ApiGroupGetRequest extends GroupControllerRequest {
+    action: "get";
+    _id: string;
+}
+export type ApiGroupGetResult = KDocument<GroupContent>;
+export interface ApiGroupUpdateRequest extends GroupControllerRequest {
+    action: "update";
+    _id: string;
+    body: GroupsBodyRequest;
+}
+export type ApiGroupUpdateResult = KDocument<GroupContent>;
+export interface ApiGroupUpsertRequest extends GroupControllerRequest {
+    action: "upsert";
+    _id?: string;
+    body: GroupsBodyRequest;
+}
+export type ApiGroupUpsertResult = KDocument<GroupContent>;
+export interface ApiGroupDeleteRequest extends GroupControllerRequest {
+    action: "delete";
+    _id: string;
+}
+export type ApiGroupDeleteResult = void;
+export interface ApiGroupSearchRequest extends GroupControllerRequest {
+    action: "search";
+    from?: number;
+    size?: number;
+    scrollTTL?: string;
+    lang?: "koncorde" | "elasticsearch";
+    body: JSONObject;
+}
+export type ApiGroupSearchResult = SearchResult<KHit<GroupContent>>;
+export interface ApiGroupListItemsRequest extends GroupControllerRequest {
+    action: "listItems";
+    from?: number;
+    size?: number;
+    body: {
+        includeChildren?: boolean;
+    };
+    _id: string;
+}
+export type ApiGroupListItemsResult = {
+    assets: {
+        hits: Array<KHit<AssetContent>>;
+        total: number;
+    };
+    devices: {
+        hits: Array<KHit<DeviceContent>>;
+        total: number;
+    };
+};
+export interface ApiGroupAddAssetsRequest extends GroupControllerRequest {
+    action: "addAssets";
+    body: {
+        path: string;
+        assetIds: string[];
+    };
+}
+export type ApiGroupAddAssetsResult = UpdateLinkResponse;
+export interface ApiGroupRemoveAssetsRequest extends GroupControllerRequest {
+    action: "removeAssets";
+    body: {
+        path: string;
+        assetIds: string[];
+    };
+}
+export type ApiGroupRemoveAssetsResult = UpdateLinkResponse;
+export interface ApiGroupAddDevicesRequest extends GroupControllerRequest {
+    action: "addDevices";
+    body: {
+        path: string;
+        deviceIds: string[];
+    };
+}
+export type ApiGroupAddDevicesResult = UpdateLinkResponse;
+export interface ApiGroupRemoveDevicesRequest extends GroupControllerRequest {
+    action: "removeDevices";
+    body: {
+        path: string;
+        deviceIds: string[];
+    };
+}
+export type ApiGroupRemoveDevicesResult = UpdateLinkResponse;
+export interface ApiGroupMCreateRequest extends GroupControllerRequest {
+    action: "mCreate";
+    body: {
+        groups: Array<GroupsBodyRequest & {
+            _id?: string;
+        }>;
+    };
+}
+export type ApiGroupMCreateResult = mCreateResponse & {
+    successes: Array<{
+        _id: string;
+        _source: GroupContent;
+        created: boolean;
+    }>;
+};
+export interface ApiGroupMUpdateRequest extends GroupControllerRequest {
+    action: "mUpdate";
+    body: {
+        groups: Array<GroupsBody & {
+            _id: string;
+        }>;
+    };
+}
+export type ApiGroupMUpdateResult = {
+    errors: mUpdateResponse["errors"];
+    successes: KDocument<GroupContent>[];
+};
+export interface ApiGroupMUpsertRequest extends GroupControllerRequest {
+    action: "mUpsert";
+    body: {
+        groups: Array<GroupsBody & {
+            _id?: string;
+        }>;
+    };
+}
+export type ApiGroupMUpsertResult = {
+    errors: Array<ApiGroupMCreateResult["errors"][0] | ApiGroupMUpdateResult["errors"][0]>;
+    successes: Array<ApiGroupMCreateResult["successes"][0] | ApiGroupMUpdateResult["successes"][0]>;
+};
+export {};