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

package/dist/lib/modules/device/DeviceService.js

@@ -1,15 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceService = void 0;
 const kuzzle_1 = require("kuzzle");
 const kuzzle_plugin_commons_1 = require("kuzzle-plugin-commons");
 const plugin_1 = require("../plugin");
 const shared_1 = require("../shared");
+const asset_1 = require("../asset");
 const DeviceSerializer_1 = require("./model/DeviceSerializer");
-const lodash_1 = __importDefault(require("lodash"));
 class DeviceService extends shared_1.DigitalTwinService {
     constructor(plugin, logger) {
         super(plugin, plugin_1.InternalCollection.DEVICES);
@@ -17,14 +14,6 @@ class DeviceService extends shared_1.DigitalTwinService {
     }
     registerAskEvents() {
         super.registerAskEvents();
-        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:device:link-asset", async ({ deviceId, engineId, user, assetId, measureNames }) => {
-            const request = new kuzzle_1.KuzzleRequest({ refresh: "false" }, { user });
-            await this.linkAsset(engineId, deviceId, assetId, measureNames, false, request);
-        });
-        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:device:unlink-asset", async ({ deviceId, user }) => {
-            const request = new kuzzle_1.KuzzleRequest({ refresh: "false" }, { user });
-            await this.unlinkAsset(deviceId, request);
-        });
         (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:device:detach-engine", async ({ deviceId, user }) => {
             const request = new kuzzle_1.KuzzleRequest({ refresh: "false" }, { user });
             await this.detachEngine(deviceId, request);
@@ -33,41 +22,32 @@ class DeviceService extends shared_1.DigitalTwinService {
             const request = new kuzzle_1.KuzzleRequest({ refresh: "false" }, { user });
             await this.attachEngine(engineId, deviceId, request);
         });
+        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:device:refresh-model", this.refreshModel.bind(this));
     }
     async _create(deviceId, model, reference, metadata, request) {
-        var _a;
         let device = {
             _id: deviceId,
             _source: {
-                assetId: null,
                 engineId: null,
-                lastMeasuredAt: 0,
-                measures: {},
+                groups: [],
+                linkedMeasures: [],
+                measureSlots: [],
                 metadata,
                 model,
                 reference,
             },
         };
         const deviceModel = await this.getDeviceModel(model);
-        const engineId = request.getString("engineId");
-        for (const metadataName of Object.keys(deviceModel.device.metadataMappings)) {
-            (_a = device._source.metadata)[metadataName] ?? (_a[metadataName] = null);
-        }
-        for (const [metadataName, metadataValue] of Object.entries(deviceModel.device.defaultMetadata)) {
-            lodash_1.default.set(device._source.metadata, metadataName, metadataValue);
-        }
+        const engineId = request.getString("engineId", "");
+        device._source.measureSlots = deviceModel.device.measures;
         const refreshableCollections = [];
-        const { _source } = await this.createDocument(request, device, {
-            collection: plugin_1.InternalCollection.DEVICES,
-            engineId: this.config.adminIndex,
-        });
-        device._source = _source;
+        await this._createDeviceProvisioning(device, request);
         refreshableCollections.push({
             collection: plugin_1.InternalCollection.DEVICES,
-            index: this.config.adminIndex,
+            index: this.config.platformIndex,
         });
-        if (engineId && engineId !== this.config.adminIndex) {
-            device = await this._attachEngine(engineId, device._id, request);
+        if (engineId.trim() !== "" && engineId !== this.config.platformIndex) {
+            device = await this._attachEngine(engineId, device._id, request, metadata);
             refreshableCollections.push({
                 collection: plugin_1.InternalCollection.DEVICES,
                 index: engineId,
@@ -78,16 +58,32 @@ class DeviceService extends shared_1.DigitalTwinService {
         }
         return device;
     }
+    async _createDeviceProvisioning(device, request) {
+        const deviceProvisioning = await this.createDocument(request, {
+            _id: device._id,
+            _source: {
+                engineId: null,
+                lastMeasuredAt: null,
+                lastMeasures: [],
+                measureSlots: device._source.measureSlots,
+                model: device._source.model,
+                provisionedAt: Date.now(),
+                reference: device._source.reference,
+            },
+        }, {
+            collection: plugin_1.InternalCollection.DEVICES,
+            engineId: this.config.platformIndex,
+        });
+        return deviceProvisioning;
+    }
     /**
      * Create a new device.
      *
-     * @todo creating a device in the "device-manager" index should be a separate
-     * method since in this case "engineId" is not really an engine ID but still
-     * required as an argument (in part to check the tenant rights)
      */
     async create(model, reference, metadata, request) {
         const deviceId = DeviceSerializer_1.DeviceSerializer.id(model, reference);
-        return (0, shared_1.lock)(`device:${deviceId}`, async () => this._create(deviceId, model, reference, metadata, request));
+        const device = await (0, shared_1.lock)(`device:${deviceId}`, async () => this._create(deviceId, model, reference, metadata, request));
+        return device;
     }
     async get(engineId, deviceId, request) {
         return this.getDocument(request, deviceId, {
@@ -95,9 +91,6 @@ class DeviceService extends shared_1.DigitalTwinService {
             engineId,
         });
     }
-    async getInternalDevices(deviceId) {
-        return this.sdk.document.get(this.config.adminIndex, plugin_1.InternalCollection.DEVICES, deviceId);
-    }
     /**
      * Replace a device metadata
      */
@@ -124,19 +117,19 @@ class DeviceService extends shared_1.DigitalTwinService {
     async upsert(engineId, model, reference, metadata, request) {
         const deviceId = DeviceSerializer_1.DeviceSerializer.id(model, reference);
         return (0, shared_1.lock)(`device:${deviceId}`, async () => {
-            const adminIndexDevice = await this.get(this.config.adminIndex, deviceId, request).catch(() => null);
-            if (!adminIndexDevice) {
+            const deviceProvisioning = await this.get(this.config.platformIndex, deviceId, request).catch(() => null);
+            if (!deviceProvisioning) {
                 return this._create(deviceId, model, reference, metadata, request);
             }
-            if (adminIndexDevice._source.engineId &&
-                adminIndexDevice._source.engineId !== engineId) {
-                throw new kuzzle_1.BadRequestError(`Device "${adminIndexDevice._id}" already exists on another engine. Abort`);
+            if (deviceProvisioning._source.engineId &&
+                deviceProvisioning._source.engineId !== engineId) {
+                throw new kuzzle_1.BadRequestError(`Device "${deviceProvisioning._id}" already exists on another engine. Abort`);
             }
             const engineDevice = await this.get(engineId, deviceId, request).catch(() => null);
             if (!engineDevice) {
                 await this._attachEngine(engineId, deviceId, request);
             }
-            const updatedPayload = await this.app.trigger("device-manager:device:update:before", { device: adminIndexDevice, metadata });
+            const updatedPayload = await this.app.trigger("device-manager:device:update:before", { device: deviceProvisioning, metadata });
             const updatedDevice = await this.updateDocument(request, {
                 _id: deviceId,
                 _source: { metadata: updatedPayload.metadata },
@@ -170,38 +163,37 @@ class DeviceService extends shared_1.DigitalTwinService {
         return (0, shared_1.lock)(`device:${deviceId}`, async () => {
             const device = await this.get(engineId, deviceId, request);
             const promises = [];
-            if (device._source.assetId) {
-                const asset = await this.sdk.document.get(engineId, plugin_1.InternalCollection.ASSETS, device._source.assetId);
-                const linkedDevices = asset._source.linkedDevices.filter((link) => link._id !== device._id);
-                promises.push(
-                // Potential race condition if someone update the asset linkedDevices
-                // at the same time (e.g link or unlink asset)
-                this.updateDocument(request, {
-                    _id: device._source.assetId,
-                    _source: { linkedDevices },
-                }, { collection: plugin_1.InternalCollection.ASSETS, engineId }).then(async (updatedAsset) => {
-                    const event = {
-                        name: "unlink",
-                        unlink: {
-                            deviceId,
-                        },
-                    };
-                    await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:history:add", {
-                        engineId,
-                        histories: [
-                            {
-                                asset: updatedAsset._source,
-                                event,
-                                id: updatedAsset._id,
-                                timestamp: Date.now(),
+            if (device._source.linkedMeasures?.length) {
+                const { successes: assets } = await this.sdk.document.mGet(engineId, plugin_1.InternalCollection.ASSETS, device._source.linkedMeasures.map((link) => link.assetId));
+                for (const asset of assets) {
+                    const linkedDevices = asset._source.linkedMeasures.filter((link) => link.deviceId !== device._id);
+                    promises.push((0, shared_1.lock)(`asset:${engineId}:${asset._id}`, async () => this.updateDocument(request, {
+                        _id: asset._id,
+                        _source: { linkedMeasures: linkedDevices },
+                    }, { collection: plugin_1.InternalCollection.ASSETS, engineId }).then(async (updatedAsset) => {
+                        const event = {
+                            name: "unlink",
+                            unlink: {
+                                deviceId,
                             },
-                        ],
-                    });
-                }));
+                        };
+                        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:history:add", {
+                            engineId,
+                            histories: [
+                                {
+                                    asset: updatedAsset._source,
+                                    event,
+                                    id: updatedAsset._id,
+                                    timestamp: Date.now(),
+                                },
+                            ],
+                        });
+                    })));
+                }
             }
             promises.push(this.deleteDocument(request, deviceId, {
                 collection: plugin_1.InternalCollection.DEVICES,
-                engineId: this.config.adminIndex,
+                engineId: this.config.platformIndex,
             }));
             promises.push(this.deleteDocument(request, deviceId, {
                 collection: plugin_1.InternalCollection.DEVICES,
@@ -216,16 +208,47 @@ class DeviceService extends shared_1.DigitalTwinService {
             engineId,
         });
     }
+    async unlinkAssets(deviceId, allMeasures, assetIds, measureSlots, request) {
+        const engineId = request.getString("engineId");
+        let device = await this.get(engineId, deviceId, request);
+        const assets = [];
+        // CASE ALL MEASURES TO UNLINK
+        if (allMeasures) {
+            const assetsToUnlink = device._source.linkedMeasures.map((m) => m.assetId);
+            if (assetsToUnlink.length === 0) {
+                throw new kuzzle_1.BadRequestError(`Device ${deviceId} has no measure to be unlinked`);
+            }
+            for (const asset of assetsToUnlink) {
+                const { asset: updatedAsset, device: updatedDevice } = await this.unlinkAssetDevice(deviceId, asset, [], true, request);
+                assets.push(asset_1.AssetSerializer.serialize(updatedAsset));
+                device = DeviceSerializer_1.DeviceSerializer.serialize(updatedDevice);
+            }
+            return { assets, device };
+        }
+        // CASE ALL MEASURES FROM SPECIFIC ASSETS TO UNLINK
+        for (const asset of assetIds) {
+            const { asset: updatedAsset, device: updatedDevice } = await this.unlinkAssetDevice(deviceId, asset, [], true, request);
+            assets.push(asset_1.AssetSerializer.serialize(updatedAsset));
+            device = DeviceSerializer_1.DeviceSerializer.serialize(updatedDevice);
+        }
+        // CASE SPECIFIC DEVICE SLOTS
+        // FOR EVERY LINK THAT HAS A SLOT TO UNLINK
+        for (const linkedMeasures of device._source.linkedMeasures.filter((l) => l.measureSlots.some((s) => measureSlots.includes(s.device)))) {
+            const { asset: updatedAsset, device: updatedDevice } = await this.unlinkAssetDevice(deviceId, linkedMeasures.assetId, linkedMeasures.measureSlots.filter((slot) => measureSlots.includes(slot.device)), false, request);
+            assets.push(asset_1.AssetSerializer.serialize(updatedAsset));
+            device = DeviceSerializer_1.DeviceSerializer.serialize(updatedDevice);
+        }
+        return { assets, device };
+    }
     /**
      * Internal logic to attach the device to an engine
      *
      * @param engineId Engine id to attach to
      * @param deviceId Device id to attach
      * @param options.refresh Wait for ES indexation
-     * @param options.strict If true, throw if an operation isn't possible
      */
-    async _attachEngine(engineId, deviceId, request) {
-        const device = await this.getInternalDevices(deviceId);
+    async _attachEngine(engineId, deviceId, request, metadata) {
+        const device = await this.getDeviceProvisioning(deviceId);
         if (device._source.engineId) {
             throw new kuzzle_1.BadRequestError(`Device "${device._id}" is already attached to an engine.`);
         }
@@ -233,18 +256,36 @@ class DeviceService extends shared_1.DigitalTwinService {
         device._source.engineId = engineId;
         await this.updateDocument(request, device, {
             collection: plugin_1.InternalCollection.DEVICES,
-            engineId: this.config.adminIndex,
+            engineId: this.config.platformIndex,
         });
         // Make sure the device is cleaned when attached to tenant
-        device._source.lastMeasuredAt = null;
-        device._source.measures = {};
-        const updatedDevice = await this.createDocument(request, device, {
+        const engineDevice = {
+            _id: device._id,
+            _source: {
+                engineId,
+                groups: [],
+                linkedMeasures: [],
+                measureSlots: device._source.measureSlots,
+                metadata: {},
+                model: device._source.model,
+                reference: device._source.reference,
+            },
+        };
+        const deviceModel = await this.getDeviceModel(engineDevice._source.model);
+        // Initialize metadata
+        for (const metadataName of Object.keys(deviceModel.device.metadataMappings)) {
+            engineDevice._source.metadata[metadataName] =
+                metadata?.[metadataName] ??
+                    deviceModel.device.defaultMetadata[metadataName] ??
+                    null;
+        }
+        const updatedDevice = await this.createDocument(request, engineDevice, {
             collection: plugin_1.InternalCollection.DEVICES,
             engineId,
         });
         if (request.getRefresh() === "wait_for") {
             await Promise.all([
-                this.sdk.collection.refresh(this.config.adminIndex, plugin_1.InternalCollection.DEVICES),
+                this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.DEVICES),
                 this.sdk.collection.refresh(device._source.engineId, plugin_1.InternalCollection.DEVICES),
             ]);
         }
@@ -269,114 +310,29 @@ class DeviceService extends shared_1.DigitalTwinService {
      */
     async detachEngine(deviceId, request) {
         return (0, shared_1.lock)(`device:${deviceId}`, async () => {
-            const device = await this.getInternalDevices(deviceId);
-            this.checkAttachedToEngine(device);
-            if (device._source.assetId) {
-                await this.unlinkAsset(deviceId, request);
+            const deviceProvisioning = await this.getDeviceProvisioning(deviceId);
+            this.checkAttachedToEngine(deviceProvisioning);
+            const device = await this.sdk.document.get(deviceProvisioning._source.engineId, plugin_1.InternalCollection.DEVICES, deviceId);
+            if (device._source.linkedMeasures?.length) {
+                await Promise.all(device._source.linkedMeasures.map((link) => this.unlinkAssetDevice(deviceId, link.assetId, [], true, request)));
             }
             await Promise.all([
                 this.updateDocument(request, {
-                    _id: device._id,
+                    _id: deviceProvisioning._id,
                     _source: { engineId: null },
                 }, {
                     collection: plugin_1.InternalCollection.DEVICES,
-                    engineId: this.config.adminIndex,
+                    engineId: this.config.platformIndex,
                 }),
-                this.sdk.document.delete(device._source.engineId, plugin_1.InternalCollection.DEVICES, device._id),
+                this.sdk.document.delete(deviceProvisioning._source.engineId, plugin_1.InternalCollection.DEVICES, deviceProvisioning._id),
             ]);
             if (request.getRefresh() === "wait_for") {
                 await Promise.all([
-                    this.sdk.collection.refresh(this.config.adminIndex, plugin_1.InternalCollection.DEVICES),
-                    this.sdk.collection.refresh(device._source.engineId, plugin_1.InternalCollection.DEVICES),
+                    this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.DEVICES),
+                    this.sdk.collection.refresh(deviceProvisioning._source.engineId, plugin_1.InternalCollection.DEVICES),
                 ]);
             }
-            return device;
-        });
-    }
-    /**
-     * Link a device to an asset.
-     */
-    async linkAsset(engineId, deviceId, assetId, measureNames, implicitMeasuresLinking, request) {
-        return (0, shared_1.lock)(`device:${deviceId}`, async () => {
-            const device = await this.getInternalDevices(deviceId);
-            const engine = await this.getEngine(engineId);
-            this.checkAttachedToEngine(device);
-            if (device._source.engineId !== engineId) {
-                throw new kuzzle_1.BadRequestError(`Device "${device._id}" is not attached to the specified engine.`);
-            }
-            if (device._source.assetId && device._source.assetId !== assetId) {
-                throw new kuzzle_1.BadRequestError(`Device "${device._id}" is already linked to another asset.`);
-            }
-            const asset = await this.sdk.document.get(device._source.engineId, plugin_1.InternalCollection.ASSETS, assetId);
-            // Remove existing links for this device
-            asset._source.linkedDevices = asset._source.linkedDevices.filter((link) => {
-                return link._id !== deviceId;
-            });
-            const [assetModel, deviceModel] = await Promise.all([
-                this.getAssetModel(engine.group, asset._source.model),
-                this.getDeviceModel(device._source.model),
-            ]);
-            const updatedMeasureNames = [];
-            for (const measure of measureNames) {
-                const foundMeasure = deviceModel.device.measures.find((deviceMeasure) => deviceMeasure.name === measure.device);
-                if (!foundMeasure && !implicitMeasuresLinking) {
-                    throw new kuzzle_1.BadRequestError(`Measure "${measure.asset}" is not declared in the device model "${measure.device}".`);
-                }
-                const { type } = foundMeasure;
-                updatedMeasureNames.push({
-                    asset: measure.asset,
-                    device: measure.device,
-                    type,
-                });
-            }
-            this.checkAlreadyProvidedMeasures(asset, updatedMeasureNames);
-            if (implicitMeasuresLinking) {
-                this.generateMissingAssetMeasureNames(asset, assetModel, deviceModel, updatedMeasureNames);
-            }
-            device._source.assetId = assetId;
-            asset._source.linkedDevices.push({
-                _id: deviceId,
-                measureNames: updatedMeasureNames,
-            });
-            const [updatedDevice, , updatedAsset] = await Promise.all([
-                this.updateDocument(request, device, {
-                    collection: plugin_1.InternalCollection.DEVICES,
-                    engineId: this.config.adminIndex,
-                }, { source: true }),
-                this.updateDocument(request, device, {
-                    collection: plugin_1.InternalCollection.DEVICES,
-                    engineId: device._source.engineId,
-                }),
-                this.updateDocument(request, asset, {
-                    collection: plugin_1.InternalCollection.ASSETS,
-                    engineId: device._source.engineId,
-                }, { source: true }),
-            ]);
-            const event = {
-                link: {
-                    deviceId: device._id,
-                },
-                name: "link",
-            };
-            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:history:add", {
-                engineId,
-                histories: [
-                    {
-                        asset: updatedAsset._source,
-                        event,
-                        id: updatedAsset._id,
-                        timestamp: Date.now(),
-                    },
-                ],
-            });
-            if (request.getRefresh() === "wait_for") {
-                await Promise.all([
-                    this.sdk.collection.refresh(this.config.adminIndex, plugin_1.InternalCollection.DEVICES),
-                    this.sdk.collection.refresh(device._source.engineId, plugin_1.InternalCollection.DEVICES),
-                    this.sdk.collection.refresh(device._source.engineId, plugin_1.InternalCollection.ASSETS),
-                ]);
-            }
-            return { asset: updatedAsset, device: updatedDevice };
+            return deviceProvisioning;
         });
     }
     async receiveMeasures(engineId, deviceId, measures, payloadUuids, request) {
@@ -394,113 +350,6 @@ class DeviceService extends shared_1.DigitalTwinService {
             payloadUuids,
         });
     }
-    /**
-     * Checks if the asset does not already have a linked device using one of the
-     * requested measure names.
-     */
-    checkAlreadyProvidedMeasures(asset, requestedMeasureNames) {
-        const measureAlreadyProvided = (assetMeasureName) => {
-            return asset._source.linkedDevices.some((link) => link.measureNames.some((names) => names.asset === assetMeasureName));
-        };
-        for (const name of requestedMeasureNames) {
-            if (measureAlreadyProvided(name.asset)) {
-                throw new kuzzle_1.BadRequestError(`Measure name "${name.asset}" is already provided by another device on this asset.`);
-            }
-        }
-    }
-    /**
-     * Goes through the device available measures and add them into the link if:
-     *  - they are not already provided by another device
-     *  - they are not already present in the link request
-     *  - they are declared in the asset model
-     */
-    generateMissingAssetMeasureNames(asset, assetModel, deviceModel, requestedMeasureNames) {
-        const measureAlreadyProvided = (deviceMeasureName) => {
-            return asset._source.linkedDevices.some((link) => link.measureNames.some((names) => names.device === deviceMeasureName));
-        };
-        const measureAlreadyRequested = (deviceMeasureName) => {
-            return requestedMeasureNames.some((names) => names.device === deviceMeasureName);
-        };
-        const measureUndeclared = (deviceMeasureName) => {
-            return !assetModel.asset.measures.some((measure) => measure.name === deviceMeasureName);
-        };
-        for (const deviceMeasure of deviceModel.device.measures) {
-            if (measureAlreadyRequested(deviceMeasure.name) ||
-                measureAlreadyProvided(deviceMeasure.name) ||
-                measureUndeclared(deviceMeasure.name)) {
-                continue;
-            }
-            requestedMeasureNames.push({
-                asset: deviceMeasure.name,
-                device: deviceMeasure.name,
-                type: deviceMeasure.type,
-            });
-        }
-    }
-    /**
-     * Internal logic of unlink a device of an asset
-     *
-     * @param {string} deviceId Id of the device
-     * @param {KuzzleRequest} request kuzzle request
-     */
-    async _unlinkAsset(deviceId, request) {
-        const device = await this.getInternalDevices(deviceId);
-        const engineId = device._source.engineId;
-        this.checkAttachedToEngine(device);
-        if (!device._source.assetId) {
-            throw new kuzzle_1.BadRequestError(`Device "${device._id}" is not linked to an asset.`);
-        }
-        const asset = await this.sdk.document.get(engineId, plugin_1.InternalCollection.ASSETS, device._source.assetId);
-        const linkedDevices = asset._source.linkedDevices.filter((link) => link._id !== device._id);
-        const [updatedDevice, , updatedAsset] = await Promise.all([
-            this.updateDocument(request, { _id: device._id, _source: { assetId: null } }, {
-                collection: plugin_1.InternalCollection.DEVICES,
-                engineId: this.config.adminIndex,
-            }, { source: true }),
-            this.updateDocument(request, { _id: device._id, _source: { assetId: null } }, {
-                collection: plugin_1.InternalCollection.DEVICES,
-                engineId,
-            }),
-            this.updateDocument(request, { _id: asset._id, _source: { linkedDevices } }, {
-                collection: plugin_1.InternalCollection.ASSETS,
-                engineId,
-            }, { source: true }),
-        ]);
-        const event = {
-            name: "unlink",
-            unlink: {
-                deviceId,
-            },
-        };
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:history:add", {
-            engineId,
-            histories: [
-                {
-                    asset: updatedAsset._source,
-                    event,
-                    id: updatedAsset._id,
-                    timestamp: Date.now(),
-                },
-            ],
-        });
-        if (request.getRefresh() === "wait_for") {
-            await Promise.all([
-                this.sdk.collection.refresh(this.config.adminIndex, plugin_1.InternalCollection.DEVICES),
-                this.sdk.collection.refresh(engineId, plugin_1.InternalCollection.DEVICES),
-                this.sdk.collection.refresh(engineId, plugin_1.InternalCollection.ASSETS),
-            ]);
-        }
-        return { asset: updatedAsset, device: updatedDevice };
-    }
-    /**
-     * Unlink a device of an asset with lock
-     *
-     * @param {string} deviceId Id of the device
-     * @param {KuzzleRequest} request kuzzle request
-     */
-    async unlinkAsset(deviceId, request) {
-        return (0, shared_1.lock)(`device:${deviceId}`, async () => this._unlinkAsset(deviceId, request));
-    }
     async checkEngineExists(engineId) {
         const { result: { exists }, } = await this.sdk.query({
             action: "exists",
@@ -516,16 +365,33 @@ class DeviceService extends shared_1.DigitalTwinService {
             throw new kuzzle_1.BadRequestError(`Device "${device._id}" is not attached to an engine.`);
         }
     }
-    getDeviceModel(model) {
-        return (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:model:device:get", {
-            model,
+    async refreshModel({ deviceModel, }) {
+        const engines = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:list", {
+            group: null,
         });
-    }
-    getAssetModel(engineGroup, model) {
-        return (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:model:asset:get", {
-            engineGroup,
-            model,
+        const targets = engines.map((engine) => ({
+            collections: [plugin_1.InternalCollection.DEVICES],
+            index: engine.index,
+        }));
+        const devices = await this.sdk.query({
+            action: "search",
+            body: { query: { equals: { model: deviceModel.device.model } } },
+            controller: "document",
+            lang: "koncorde",
+            targets,
         });
+        const updatedDevicesPerIndex = devices.result.hits.reduce((acc, device) => {
+            device._source.measureSlots = deviceModel.device.measures;
+            acc[device.index].push(device);
+            return acc;
+        }, Object.fromEntries(engines.map((engine) => [
+            engine.index,
+            [],
+        ])));
+        await Promise.all(Object.entries(updatedDevicesPerIndex).map(([index, updatedDevices]) => this.sdk.document.mReplace(index, plugin_1.InternalCollection.DEVICES, updatedDevices.map((device) => ({
+            _id: device._id,
+            body: device._source,
+        })), { refresh: "wait_for" })));
     }
 }
 exports.DeviceService = DeviceService;