kuzzle-device-manager 0.4.8 → 0.4.9

package/lib/core-classes/Decoder.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decoder = void 0;
+const kuzzle_1 = require("kuzzle");
+const lodash_1 = __importDefault(require("lodash"));
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-function */
+/**
+ * Base class to implement a decoder for a device model.
+ * The device model must be passed to the parent constructor.
+ * The abstract "decode" method must be implemented.
+ */
+class Decoder {
+    /**
+     * @param deviceModel Device model for this decoder
+     */
+    constructor(deviceModel) {
+        /**
+         * Custom mappings for the payload collection.
+         * It will be injected in the "payload" property and it should allows to index
+         * the device model unique identifier field.
+         *
+         * @example
+         * this.payloadsMappings = {
+         *   device_properties: {
+         *     properties: {
+         *       deveui: { type: 'keyword' }
+         *     }
+         *   }
+         * }
+         */
+        this.payloadsMappings = {};
+        this.deviceModel = deviceModel;
+    }
+    /**
+     * Define custom HTTP routes
+     *
+     * @param http HttpRoute array
+     */
+    set http(http) {
+        this._http = http;
+    }
+    get http() {
+        return this._http || [{ verb: 'post', path: `device-manager/payload/${this.action}` }];
+    }
+    /**
+     * Validate the payload format before processing.
+     *
+     * If the method:
+     *   - return true: the payload will be processed (status 200)
+     *   - return false: the payload will be skipped (status 200)
+     *   - throw an error: the payload will be skipped (status 4** or 5**)
+     *
+     * @param payload Raw payload received in the API action body
+     * @param request Original request
+     *
+     * @return A boolean indicating if the payload is valid
+     */
+    async validate(payload, request) {
+        return true;
+    }
+    /**
+     * Hook executed before processing the payload but after validation
+     *
+     * @param payload Raw payload received in the API action body
+     * @param request Original request
+     */
+    async beforeProcessing(payload, request) {
+    }
+    /**
+     * Enrichment hook executed before registering a device
+     *
+     * @param device Densor before being persisted
+     * @param request Original request
+     *
+     * @returns Enriched device
+     */
+    async beforeRegister(device, request) {
+        return device;
+    }
+    /**
+     * Hook executed after registering a device.
+     * Return value of this method will be returned in the API action result.
+     *
+     * @param device Device after being persisted
+     * @param request Original request
+     *
+     * @returns Result of the corresponding API action
+     */
+    async afterRegister(device, request) {
+        return {
+            tenantId: device._source.tenantId,
+            device: device.serialize(),
+            asset: null,
+        };
+    }
+    /**
+    * Enrichment hook executed before updating a device
+    *
+    * @param device Device before being updated
+    * @param request Original request
+    *
+    * @returns Enriched device
+    */
+    async beforeUpdate(device, request) {
+        return device;
+    }
+    /**
+     * Hook executed after updating a device.
+     * Return value of this method will be returned in the API action result.
+     *
+     * @param device Device after being updated
+     * @param request Original request
+     *
+     * @returns Result of the corresponding API action
+     */
+    async afterUpdate(device, asset, request) {
+        return {
+            tenantId: device._source.tenantId,
+            device: device.serialize(),
+            asset: asset ? asset.serialize() : null,
+        };
+    }
+    /**
+     * Build the "measures" property that will be persisted in the asset document
+     *
+     * @param device Device after being updated
+     *
+     * @returns Content of the "measures" property
+     */
+    async copyToAsset(device) {
+        const measures = {};
+        for (const [measureType, measure] of Object.entries(device._source.measures)) {
+            measures[measureType] = {
+                id: device._id,
+                model: device._source.model,
+                reference: device._source.reference,
+                ...measure,
+                qos: device._source.qos,
+            };
+        }
+        return measures;
+    }
+    /**
+     * Checks if the provided properties are present in the payload
+     *
+     * @param payload Raw payload received in the API action body
+     * @param paths Paths of properties (lodash style)
+     *
+     * @throws
+     */
+    ensureProperties(payload, paths) {
+        for (const path of paths) {
+            if (!lodash_1.default.has(payload, path)) {
+                throw new kuzzle_1.PreconditionError(`Missing property "${path}" in payload`);
+            }
+        }
+    }
+}
+exports.Decoder = Decoder;
+/* eslint-enable @typescript-eslint/no-unused-vars */
+/* eslint-enable @typescript-eslint/no-empty-function */
+//# sourceMappingURL=Decoder.js.map

package/lib/core-classes/DeviceManagerEngine.d.ts

@@ -0,0 +1,21 @@
+import { Plugin } from 'kuzzle';
+import { AbstractEngine } from 'kuzzle-plugin-commons';
+import { DeviceManagerConfig, DeviceManagerPlugin } from '../DeviceManagerPlugin';
+import { AssetMappingsManager } from './CustomMappings/AssetMappingsManager';
+import { DeviceMappingsManager } from './CustomMappings/DeviceMappingsManager';
+export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlugin> {
+    config: DeviceManagerConfig;
+    private assetMappings;
+    private deviceMappings;
+    constructor(plugin: Plugin, assetMappings: AssetMappingsManager, deviceMappings: DeviceMappingsManager);
+    onCreate(index: string, group?: string): Promise<{
+        collections: string[];
+    }>;
+    onUpdate(index: string, group?: string): Promise<{
+        collections: string[];
+    }>;
+    onDelete(index: string): Promise<{
+        collections: string[];
+    }>;
+    private getAssetsHistoryMappings;
+}

package/lib/core-classes/DeviceManagerEngine.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceManagerEngine = void 0;
+const kuzzle_plugin_commons_1 = require("kuzzle-plugin-commons");
+const models_1 = require("../models");
+class DeviceManagerEngine extends kuzzle_plugin_commons_1.AbstractEngine {
+    constructor(plugin, assetMappings, deviceMappings) {
+        super('device-manager', plugin, plugin.config.adminIndex, plugin.config.configCollection);
+        this.assetMappings = assetMappings;
+        this.deviceMappings = deviceMappings;
+    }
+    async onCreate(index, group = 'commons') {
+        const promises = [];
+        promises.push(this.sdk.collection.create(index, 'assets', {
+            mappings: this.assetMappings.get(group)
+        }));
+        promises.push(this.sdk.collection.create(index, 'asset-history', {
+            mappings: this.getAssetsHistoryMappings(group)
+        }));
+        promises.push(this.sdk.collection.create(index, 'devices', {
+            mappings: this.deviceMappings.get()
+        }));
+        promises.push(this.sdk.collection.create(index, this.config.configCollection, {
+            mappings: {
+                dynamic: 'strict',
+                properties: {
+                    type: { type: 'keyword' },
+                    catalog: models_1.catalogMappings,
+                }
+            }
+        }));
+        await Promise.all(promises);
+        return { collections: ['assets', 'asset-history', this.config.configCollection, 'devices'] };
+    }
+    async onUpdate(index, group = 'commons') {
+        const promises = [];
+        promises.push(this.sdk.collection.create(index, 'assets', {
+            mappings: this.assetMappings.get(group)
+        }));
+        promises.push(this.sdk.collection.create(index, 'asset-history', {
+            mappings: this.getAssetsHistoryMappings(group)
+        }));
+        promises.push(this.sdk.collection.create(index, 'devices', {
+            mappings: this.deviceMappings.get()
+        }));
+        await Promise.all(promises);
+        return { collections: ['assets', 'asset-history', 'devices'] };
+    }
+    async onDelete(index) {
+        const promises = [];
+        promises.push(this.sdk.collection.delete(index, 'assets'));
+        promises.push(this.sdk.collection.delete(index, 'asset-history'));
+        promises.push(this.sdk.collection.delete(index, 'devices'));
+        await Promise.all(promises);
+        return { collections: ['assets', 'asset-history', 'devices'] };
+    }
+    getAssetsHistoryMappings(group) {
+        const mappings = JSON.parse(JSON.stringify(this.config.collections['asset-history']));
+        mappings.properties.asset = this.assetMappings.get(group);
+        return mappings;
+    }
+}
+exports.DeviceManagerEngine = DeviceManagerEngine;
+//# sourceMappingURL=DeviceManagerEngine.js.map

package/lib/core-classes/DeviceService.d.ts

@@ -0,0 +1,41 @@
+import { JSONObject, EmbeddedSDK, Plugin } from 'kuzzle';
+import { DeviceBulkContent, DeviceMAttachementContent } from '../types';
+import { Decoder } from './Decoder';
+import { Device } from '../models';
+export declare class DeviceService {
+    private config;
+    private context;
+    private decoders;
+    get sdk(): EmbeddedSDK;
+    constructor(plugin: Plugin, decoders: Map<string, Decoder>);
+    mAttach(devices: Device[], bulkData: DeviceBulkContent[], { strict, options }: {
+        strict?: boolean;
+        options?: JSONObject;
+    }): Promise<DeviceMAttachementContent>;
+    mDetach(devices: Device[], bulkData: DeviceBulkContent[], { strict, options }: {
+        strict?: boolean;
+        options?: JSONObject;
+    }): Promise<{
+        errors: any[];
+        successes: any[];
+    }>;
+    mLink(devices: Device[], bulkData: DeviceBulkContent[], { strict, options }: {
+        strict?: boolean;
+        options?: JSONObject;
+    }): Promise<{
+        errors: any[];
+        successes: any[];
+    }>;
+    mUnlink(devices: Device[], { strict, options }: {
+        strict?: boolean;
+        options?: JSONObject;
+    }): Promise<{
+        errors: any[];
+        successes: any[];
+    }>;
+    private eraseAssetMeasure;
+    private tenantExists;
+    private buildBulkDevices;
+    private formatDevicesContent;
+    private writeToDatabase;
+}

package/lib/core-classes/DeviceService.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceService = void 0;
+const kuzzle_1 = require("kuzzle");
+class DeviceService {
+    constructor(plugin, decoders) {
+        this.config = plugin.config;
+        this.context = plugin.context;
+        this.decoders = decoders;
+    }
+    get sdk() {
+        return this.context.accessors.sdk;
+    }
+    async mAttach(devices, bulkData, { strict, options }) {
+        const attachedDevices = devices.filter(device => device._source.tenantId);
+        if (strict && attachedDevices.length > 0) {
+            const ids = attachedDevices.map(device => device._id).join(',');
+            throw new kuzzle_1.BadRequestError(`These devices "${ids}" are already attached to a tenant`);
+        }
+        const documents = this.buildBulkDevices(bulkData);
+        const results = {
+            errors: [],
+            successes: [],
+        };
+        for (let i = 0; i < documents.length; i++) {
+            const document = documents[i];
+            const tenantExists = await this.tenantExists(document.tenantId);
+            if (strict && !tenantExists) {
+                throw new kuzzle_1.BadRequestError(`Tenant "${document.tenantId}" does not have a device-manager engine`);
+            }
+            else if (!strict && !tenantExists) {
+                results.errors.push(`Tenant "${document.tenantId}" does not have a device-manager engine`);
+                continue;
+            }
+            const deviceDocuments = this.formatDevicesContent(devices, document);
+            const { errors, successes } = await this.writeToDatabase(deviceDocuments, async (deviceDocuments) => {
+                const updated = await this.sdk.document.mUpdate(this.config.adminIndex, 'devices', deviceDocuments, { strict, ...options });
+                await this.sdk.document.mCreate(document.tenantId, 'devices', deviceDocuments, { strict, ...options });
+                return {
+                    successes: results.successes.concat(updated.successes),
+                    errors: results.errors.concat(updated.errors)
+                };
+            });
+            results.successes.concat(successes);
+            results.errors.concat(errors);
+        }
+        return results;
+    }
+    async mDetach(devices, bulkData, { strict, options }) {
+        const detachedDevices = devices.filter(device => {
+            return !device._source.tenantId || device._source.tenantId === null;
+        });
+        if (strict && detachedDevices.length > 0) {
+            const ids = detachedDevices.map(device => device._id).join(',');
+            throw new kuzzle_1.BadRequestError(`Devices "${ids}" are not attached to a tenant`);
+        }
+        const linkedAssets = devices.filter(device => device._source.assetId);
+        if (strict && linkedAssets.length > 0) {
+            const ids = linkedAssets.map(device => device._id).join(',');
+            throw new kuzzle_1.BadRequestError(`Devices "${ids}" are still linked to an asset`);
+        }
+        const builder = bulkData.map(data => {
+            const { deviceId } = data;
+            const device = devices.find(s => s._id === deviceId);
+            return { tenantId: device._source.tenantId, deviceId };
+        });
+        const documents = this.buildBulkDevices(builder);
+        const results = {
+            errors: [],
+            successes: [],
+        };
+        for (let i = 0; i < documents.length; i++) {
+            const document = documents[i];
+            const devicesContent = devices.filter(({ _id }) => document.deviceIds.includes(_id));
+            const deviceDocuments = devicesContent.map(device => {
+                return { _id: device._id, body: { tenantId: null } };
+            });
+            const { errors, successes } = await this.writeToDatabase(deviceDocuments, async (deviceDocuments) => {
+                const updated = await this.sdk.document.mUpdate(this.config.adminIndex, 'devices', deviceDocuments, { strict, ...options });
+                await this.sdk.document.mDelete(document.tenantId, 'devices', deviceDocuments.map(device => device._id), { strict, ...options });
+                return {
+                    successes: results.successes.concat(updated.successes),
+                    errors: results.errors.concat(updated.errors)
+                };
+            });
+            results.successes.concat(successes);
+            results.errors.concat(errors);
+        }
+        return results;
+    }
+    async mLink(devices, bulkData, { strict, options }) {
+        const detachedDevices = devices.filter(device => {
+            return !device._source.tenantId || device._source.tenantId === null;
+        });
+        if (strict && detachedDevices.length > 0) {
+            const ids = detachedDevices.map(device => device._id).join(',');
+            throw new kuzzle_1.PreconditionError(`Devices "${ids}" are not attached to a tenant`);
+        }
+        const builder = bulkData.map(data => {
+            const { deviceId, assetId } = data;
+            const device = devices.find(s => s._id === deviceId);
+            return { tenantId: device._source.tenantId, deviceId, assetId };
+        });
+        const documents = this.buildBulkDevices(builder);
+        const results = {
+            errors: [],
+            successes: [],
+        };
+        for (let i = 0; i < documents.length; i++) {
+            const document = documents[i];
+            const existingAssets = await this.sdk.document.mGet(document.tenantId, 'assets', document.assetIds);
+            if (strict && existingAssets.errors.length > 0) {
+                throw new kuzzle_1.NotFoundError(`Assets "${existingAssets.errors}" do not exist`);
+            }
+            const devicesContent = devices.filter(({ _id }) => document.deviceIds.includes(_id));
+            const deviceDocuments = [];
+            const assetDocuments = [];
+            for (const device of devicesContent) {
+                const decoder = this.decoders.get(device._source.model);
+                const measures = await decoder.copyToAsset(device);
+                const { assetId } = bulkData.find(data => data.deviceId === device._id);
+                deviceDocuments.push({ _id: device._id, body: { assetId } });
+                assetDocuments.push({ _id: assetId, body: { measures } });
+            }
+            const updatedDevice = await this.writeToDatabase(deviceDocuments, async (deviceDocuments) => {
+                const updated = await this.sdk.document.mUpdate(this.config.adminIndex, 'devices', deviceDocuments, { strict, ...options });
+                await this.sdk.document.mUpdate(document.tenantId, 'devices', deviceDocuments, { strict, ...options });
+                return {
+                    successes: results.successes.concat(updated.successes),
+                    errors: results.errors.concat(updated.errors)
+                };
+            });
+            const updatedAssets = await this.writeToDatabase(assetDocuments, async (assetDocuments) => {
+                const updated = await this.sdk.document.mUpdate(document.tenantId, 'assets', assetDocuments, { strict, ...options });
+                return {
+                    successes: results.successes.concat(updated.successes),
+                    errors: results.errors.concat(updated.errors)
+                };
+            });
+            results.successes.concat(updatedDevice.successes, updatedAssets.successes);
+            results.errors.concat(updatedDevice.errors, updatedDevice.errors);
+        }
+        return results;
+    }
+    async mUnlink(devices, { strict, options }) {
+        const unlinkedDevices = devices.filter(device => !device._source.assetId);
+        if (strict && unlinkedDevices.length > 0) {
+            const ids = unlinkedDevices.map(d => d._id);
+            throw new kuzzle_1.BadRequestError(`Devices "${ids}" are not linked to an asset`);
+        }
+        const builder = devices.map(device => {
+            const { _id, _source } = device;
+            return { tenantId: _source.tenantId, deviceId: _id, assetId: _source.assetId };
+        });
+        const documents = this.buildBulkDevices(builder);
+        const results = {
+            errors: [],
+            successes: [],
+        };
+        for (let i = 0; i < documents.length; i++) {
+            const document = documents[i];
+            const devicesContent = devices.filter(({ _id }) => document.deviceIds.includes(_id));
+            const deviceDocuments = [];
+            const assetDocuments = [];
+            for (const device of devicesContent) {
+                deviceDocuments.push({ _id: device._id, body: { assetId: null } });
+                const measures = await this.eraseAssetMeasure(document.tenantId, device);
+                assetDocuments.push({ _id: device._source.assetId, body: { measures } });
+            }
+            const updatedDevice = await this.writeToDatabase(deviceDocuments, async (deviceDocuments) => {
+                const updated = await this.sdk.document.mUpdate(this.config.adminIndex, 'devices', deviceDocuments, { strict, ...options });
+                await this.sdk.document.mUpdate(document.tenantId, 'devices', deviceDocuments, { strict, ...options });
+                return {
+                    successes: results.successes.concat(updated.successes),
+                    errors: results.errors.concat(updated.errors)
+                };
+            });
+            const updatedAssets = await this.writeToDatabase(assetDocuments, async (assetDocuments) => {
+                const updated = await this.sdk.document.mUpdate(document.tenantId, 'assets', assetDocuments, { strict, ...options });
+                return {
+                    successes: results.successes.concat(updated.successes),
+                    errors: results.errors.concat(updated.errors)
+                };
+            });
+            results.successes.concat(updatedDevice.successes, updatedAssets.successes);
+            results.errors.concat(updatedDevice.errors, updatedDevice.errors);
+        }
+        return results;
+    }
+    async eraseAssetMeasure(tenantId, device) {
+        const { _source: { measures } } = await this.sdk.document.get(tenantId, 'assets', device._source.assetId);
+        for (const [measureName] of Object.entries(device._source.measures)) {
+            if (measures[measureName]) {
+                measures[measureName] = undefined;
+            }
+        }
+        return measures;
+    }
+    async tenantExists(tenantId) {
+        const { result: tenantExists } = await this.sdk.query({
+            controller: 'device-manager/engine',
+            action: 'exists',
+            index: tenantId,
+        });
+        return tenantExists;
+    }
+    buildBulkDevices(bulkData) {
+        const documents = [];
+        for (let i = 0; i < bulkData.length; i++) {
+            const { tenantId, deviceId, assetId } = bulkData[i];
+            const document = documents.find(doc => doc.tenantId === tenantId);
+            if (document) {
+                document.deviceIds.push(deviceId);
+                document.assetIds.push(assetId);
+            }
+            else {
+                documents.push({ tenantId, deviceIds: [deviceId], assetIds: [assetId] });
+            }
+        }
+        return documents;
+    }
+    formatDevicesContent(devices, document) {
+        const devicesContent = devices.filter(device => document.deviceIds.includes(device._id));
+        const devicesDocuments = devicesContent.map(device => {
+            device._source.tenantId = document.tenantId;
+            return { _id: device._id, body: device._source };
+        });
+        return devicesDocuments;
+    }
+    async writeToDatabase(deviceDocuments, writer) {
+        const results = {
+            errors: [],
+            successes: [],
+        };
+        const limit = global.kuzzle.config.limits.documentsWriteCount;
+        if (deviceDocuments.length <= limit) {
+            const { successes, errors } = await writer(deviceDocuments);
+            results.successes.push(successes);
+            results.errors.push(errors);
+            return results;
+        }
+        const writeMany = async (start, end) => {
+            const devices = deviceDocuments.slice(start, end);
+            const { successes, errors } = await writer(devices);
+            results.successes.push(successes);
+            results.errors.push(errors);
+        };
+        let offset = 0;
+        let offsetLimit = limit;
+        let done = false;
+        while (!done) {
+            await writeMany(offset, offsetLimit);
+            offset += limit;
+            offsetLimit += limit;
+            if (offsetLimit >= deviceDocuments.length) {
+                done = true;
+                await writeMany(offset, deviceDocuments.length);
+            }
+        }
+        return results;
+    }
+}
+exports.DeviceService = DeviceService;
+//# sourceMappingURL=DeviceService.js.map

package/lib/core-classes/MigrationService.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from 'kuzzle';
+export declare class MigrationService {
+    private config;
+    private context;
+    private prefix;
+    get sdk(): import("kuzzle").EmbeddedSDK;
+    constructor(pluginName: string, plugin: Plugin);
+    run(): Promise<void>;
+    /**
+     * Migrate the engine documents into the new config collection
+     */
+    private engineCollection;
+}

package/lib/core-classes/MigrationService.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationService = void 0;
+class MigrationService {
+    constructor(pluginName, plugin) {
+        this.config = plugin.config;
+        this.context = plugin.context;
+        this.prefix = pluginName;
+    }
+    get sdk() {
+        return this.context.accessors.sdk;
+    }
+    async run() {
+        global.app.install(`${this.prefix}-O.3.0`, async () => {
+            await this.engineCollection();
+        });
+    }
+    /**
+     * Migrate the engine documents into the new config collection
+     */
+    async engineCollection() {
+        if (!await this.sdk.collection.exists(this.config.adminIndex, 'engines')) {
+            return;
+        }
+        this.context.log.info('Migrate engine documents into the config collection...');
+        let result = await this.sdk.document.search(this.config.adminIndex, 'engines', {}, { scroll: '1s', size: 100 });
+        let count = 0;
+        while (result) {
+            const documents = [];
+            for (const { _id, _source } of result.hits) {
+                documents.push({
+                    _id,
+                    body: {
+                        type: 'engine-device-manager',
+                        engine: { index: _source.index },
+                    },
+                });
+            }
+            await this.sdk.document.mCreate(this.config.adminIndex, this.config.configCollection, documents, {
+                strict: true,
+            });
+            count += documents.length;
+            result = await result.next();
+        }
+        this.context.log.info(`Successfully migrated ${count} documents.`);
+    }
+}
+exports.MigrationService = MigrationService;
+//# sourceMappingURL=MigrationService.js.map

package/lib/core-classes/PayloadService.d.ts

@@ -0,0 +1,43 @@
+import { KuzzleRequest, EmbeddedSDK, Plugin } from 'kuzzle';
+import { Decoder } from './Decoder';
+import { BatchWriter } from './BatchProcessing';
+export declare type PayloadHandler = (request: KuzzleRequest, decoder: Decoder) => Promise<any>;
+export declare class PayloadService {
+    private config;
+    private context;
+    private batchController;
+    get sdk(): EmbeddedSDK;
+    constructor(plugin: Plugin, batchWriter: BatchWriter);
+    process(request: KuzzleRequest, decoder: Decoder, { refresh }?: {
+        refresh?: any;
+    }): Promise<any>;
+    private register;
+    /**
+     * Device provisioning strategy.
+     *
+     * If autoProvisionning is on, device is automatically registered, otherwise
+     * we request the admin provisioning catalog to ensure this device is allowed
+     * to register.
+     *
+     * After registration, we look at the admin provisioning catalog entry to:
+     *   - attach the device to a tenant
+     *   - link the device to an asset of this tenant
+     *
+     * Then we look into the tenant provisioning catalog entry to:
+     *   - link the device to an asset of this tenant
+     */
+    private deviceProvisionning;
+    /**
+     * Get the device entry from the provisioning catalog in corresponding index
+     */
+    private getCatalogEntry;
+    private update;
+    /**
+     * Propagate the measures inside the asset document.
+     */
+    private propagateToAsset;
+    /**
+     * Creates an history entry for an asset
+     */
+    private historizeAsset;
+}