@c8y/ngx-components 1021.35.2 → 1021.36.0

package/esm2022/device-profile/device-profile.service.mjs

@@ -1,7 +1,7 @@
 import { Injectable } from '@angular/core';
 import { InventoryService, OperationService, OperationStatus, QueriesUtil } from '@c8y/client';
 import { AlertService, gettext } from '@c8y/ngx-components';
-import { get, isNil, omitBy, sortBy, toArray } from 'lodash-es';
+import { get, isEmpty, isNil, keyBy, keys, mapValues, omitBy, pickBy, sortBy, toArray, uniqBy } from 'lodash-es';
 import * as i0 from "@angular/core";
 import * as i1 from "@c8y/client";
 import * as i2 from "@c8y/ngx-components";
@@ -23,6 +23,43 @@ export class DeviceProfileService {
         }
         return this.inventoryService.create(deviceProfile);
     }
+    /**
+     * Determines the available device profiles for a given device by considering device type
+     * and the supported software types declared by the devices. Because of limitations in the
+     * Inventory Query API the methods return profile that contain at least one of the supported
+     * software types and omits profiles having only non-supported software types. Resulting device
+     * profiles need to be further filtered on the client side to exclude the ones that contain
+     * non-supported software types next to the supported ones.
+     *
+     * @param device A device MO
+     * @param name Optional device profile name filter
+     * @returns Candidate device profiles that contain at least on software with supported type.
+     */
+    getDeviceProfilesByDevice(device, name = null) {
+        const deviceTypeFilter = {
+            __or: [
+                { 'c8y_Filter.type': device.type },
+                { 'c8y_Filter.type': '' },
+                { __not: { __has: 'c8y_Filter.type' } }
+            ]
+        };
+        let softwareTypeFilter = {};
+        if (!isEmpty(device.c8y_SupportedSoftwareTypes)) {
+            softwareTypeFilter = {
+                __hasany: device.c8y_SupportedSoftwareTypes.map((type) => `softwareType!${type}`)
+            };
+        }
+        let query = this.queriesUtil.addAndFilter(deviceTypeFilter, softwareTypeFilter);
+        let profileNameFilter = {};
+        if (!isEmpty(name)) {
+            profileNameFilter = { name: `*${name}*` };
+        }
+        query = this.queriesUtil.addAndFilter(query, profileNameFilter);
+        return this.getDeviceProfiles(query);
+    }
+    /**
+     * @deprecated Use `getDeviceProfilesByDevice` instead as it also considers the supported software types.
+     */
     getDeviceProfilesByDeviceType(deviceType) {
         const deviceTypeFilter = {
             __or: [
@@ -102,6 +139,25 @@ export class DeviceProfileService {
         const profileConfiguration = get(selectedProfile, 'c8y_DeviceProfile.configuration');
         return this.createProfileComparison(deviceConfiguration, profileConfiguration, 'url', null, 'type', this.getAlert('configuration'));
     }
+    /**
+     * Aligns device profile managed object's `softwareType!*` fragments to the software items
+     * included in the device profile. Removes obsolete software type fragments and adds new.
+     *
+     * @param profilePartial The device profile managed object which `softwareType!*` fragments will be adjusted.
+     * @returns The adjusted device profile managed object.
+     */
+    alignSoftwareTypeFragments(profilePartial, profile) {
+        if (!profilePartial?.c8y_DeviceProfile?.software || !profile) {
+            return profilePartial;
+        }
+        const removedSoftwareTypes = mapValues(omitBy(profile, (_, key) => typeof key === 'string' && !key.startsWith('softwareType!')), () => null);
+        const softwareTypesToAdd = mapValues(keyBy(uniqBy(profilePartial.c8y_DeviceProfile.software, 'softwareType'), (profile) => `softwareType!${profile.softwareType}`), () => ({}));
+        const result = { ...profilePartial, ...removedSoftwareTypes, ...softwareTypesToAdd };
+        return result;
+    }
+    getSoftwareTypes(profile) {
+        return keys(pickBy(profile, (_, key) => typeof key === 'string' && key.startsWith('softwareType!'))).map(softwareType => softwareType.substr('softwareType!'.length));
+    }
     getAlert(itemType) {
         const notInstalled = (comparisionResult) => {
             return !comparisionResult.device ? this.NOT_INSTALLED_WARNING : '';
@@ -171,4 +227,4 @@ export class DeviceProfileService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DeviceProfileService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.InventoryService }, { type: i1.OperationService }, { type: i2.AlertService }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device-profile.service.js","sourceRoot":"","sources":["../../../device-profile/device-profile.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAEL,gBAAgB,EAGhB,gBAAgB,EAChB,eAAe,EACf,WAAW,EACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;;;;AAShE,MAAM,OAAO,oBAAoB;IAW/B,YACU,gBAAkC,EAClC,gBAAkC,EAClC,YAA0B;QAF1B,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,iBAAY,GAAZ,YAAY,CAAc;QAb3B,aAAQ,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;QACvB,WAAM,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,sBAAsB;QAGjE,0BAAqB,GAAG,OAAO,CAAC,6BAA6B,CAAC,CAAC;QAC/D,8BAAyB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;QACxD,qBAAgB,GAAG,OAAO,CAChC,iGAAiG,CAClG,CAAC;QAOA,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,EAAE,CAAC;IACvC,CAAC;IAED,mBAAmB,CAAC,aAAqC;QACvD,IAAI,GAAG,CAAC,aAAa,EAAE,iBAAiB,CAAC,KAAK,EAAE,EAAE,CAAC;YACjD,OAAO,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC;QACvC,CAAC;QACD,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,aAA+B,CAAC,CAAC;IACvE,CAAC;IAED,6BAA6B,CAAC,UAAkB;QAC9C,MAAM,gBAAgB,GAAG;YACvB,IAAI,EAAE;gBACJ,EAAE,iBAAiB,EAAE,UAAU,EAAE;gBACjC,EAAE,iBAAiB,EAAE,EAAE,EAAE;gBACzB,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,iBAAiB,EAAE,EAAE;aACxC;SACF,CAAC;QACF,OAAO,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;IAClD,CAAC;IAED,iBAAiB,CAAC,QAAc;QAC9B,IAAI,KAAK,GAAW;YAClB,IAAI,EAAE,aAAa;SACpB,CAAC;QACF,MAAM,MAAM,GAAW;YACrB,QAAQ,EAAE,GAAG;YACb,cAAc,EAAE,IAAI;SACrB,CAAC;QACF,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;QAC7D,OAAO,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACxD,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,QAAyB;QACjD,MAAM,MAAM,GAAW;YACrB,QAAQ;YACR,YAAY,EAAE,mBAAmB;YACjC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE;YACrC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE;YACjC,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,CAAC;SACZ,CAAC;QAEF,MAAM,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrE,OAAO,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9F,CAAC;IAED,KAAK,CAAC,sBAAsB,CAAC,MAAsB,EAAE,aAAqC;QACxF,IAAI,SAAS,CAAC;QACd,MAAM,YAAY,GAAe;YAC/B,QAAQ,EAAE,MAAM,CAAC,EAAE;YACnB,SAAS,EAAE,aAAa,CAAC,EAAE;YAC3B,WAAW,EAAE,aAAa,CAAC,IAAI;YAC/B,iBAAiB,EAAE,aAAa,CAAC,iBAAiB;YAClD,WAAW,EAAE,yBAAyB,aAAa,CAAC,IAAI,cAAc,MAAM,CAAC,IAAI,EAAE;SACpF,CAAC;QACF,IAAI,CAAC;YACH,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAClE,SAAS,GAAG,IAAI,CAAC;QACnB,CAAC;QAAC,OAAO,EAAE,EAAE,CAAC;YACZ,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC;QACzC,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,gBAAgB,CACd,MAAsB,EACtB,eAAuC;QAEvC,MAAM,cAAc,GAAG,MAAM,CAAC,YAAY,CAAC;QAC3C,MAAM,eAAe,GAAG,GAAG,CAAC,eAAe,EAAE,4BAA4B,CAAC,CAAC;QAC3E,MAAM,WAAW,GAAG,EAAE,CAAC;QACvB,MAAM,YAAY,GAAG,EAAE,CAAC;QAExB,IAAI,cAAc,EAAE,CAAC;YACnB,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,eAAe,EAAE,CAAC;YACpB,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,IAAI,CAAC,uBAAuB,CACjC,WAAW,EACX,YAAY,EACZ,MAAM,EACN,SAAS,EACT,IAAI,EACJ,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAC1B,CAAC;IACJ,CAAC;IAED,gBAAgB,CACd,MAAsB,EACtB,eAAuC;QAEvC,MAAM,cAAc,GAAG,MAAM,CAAC,gBAAgB,CAAC;QAC/C,MAAM,eAAe,GAAG,GAAG,CAAC,eAAe,EAAE,4BAA4B,CAAC,CAAC;QAC3E,OAAO,IAAI,CAAC,uBAAuB,CACjC,cAAc,EACd,eAAe,EACf,MAAM,EACN,SAAS,EACT,cAAc,EACd,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAC1B,CAAC;IACJ,CAAC;IAED,qBAAqB,CACnB,MAAsB,EACtB,eAAuC;QAEvC,MAAM,mBAAmB,GAAG,EAAE,CAAC;QAC/B,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YAChC,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,oBAAoB,EAAE,CAAC;gBAC9C,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YACxC,CAAC;QACH,CAAC,CAAC,CAAC;QACH,MAAM,oBAAoB,GAAG,GAAG,CAAC,eAAe,EAAE,iCAAiC,CAAC,CAAC;QACrF,OAAO,IAAI,CAAC,uBAAuB,CACjC,mBAAmB,EACnB,oBAAoB,EACpB,KAAK,EACL,IAAI,EACJ,MAAM,EACN,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAC/B,CAAC;IACJ,CAAC;IAEO,QAAQ,CAAC,QAAgB;QAC/B,MAAM,YAAY,GAAG,CAAC,iBAAmC,EAAE,EAAE;YAC3D,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,EAAE,CAAC;QACrE,CAAC,CAAC;QAEF,QAAQ,QAAQ,EAAE,CAAC;YACjB,KAAK,UAAU,CAAC;YAChB,KAAK,UAAU;gBACb,OAAO,CAAC,iBAAmC,EAAE,EAAE;oBAC7C,OAAO,iBAAiB,CAAC,MAAM;wBAC7B,iBAAiB,CAAC,OAAO;wBACzB,iBAAiB,CAAC,MAAM,CAAC,WAAW,KAAK,iBAAiB,CAAC,OAAO,CAAC,WAAW;wBAC9E,CAAC,CAAC,IAAI,CAAC,yBAAyB;wBAChC,CAAC,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;gBACtC,CAAC,CAAC;YACJ,KAAK,eAAe;gBAClB,OAAO,CAAC,iBAAmC,EAAE,EAAE;oBAC7C,OAAO,iBAAiB,CAAC,MAAM;wBAC7B,iBAAiB,CAAC,OAAO;wBACzB,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,KAAK,iBAAiB,CAAC,OAAO,CAAC,QAAQ;4BACvE,iBAAiB,CAAC,MAAM,CAAC,WAAW,KAAK,iBAAiB,CAAC,OAAO,CAAC,WAAW,CAAC;wBACjF,CAAC,CAAC,IAAI,CAAC,gBAAgB;wBACvB,CAAC,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;gBACtC,CAAC,CAAC;YACJ;gBACE,OAAO,YAAY,CAAC;QACxB,CAAC;IACH,CAAC;IAEO,uBAAuB,CAC7B,cAAqB,EAAE,EACvB,eAAqE,EAAE,EACvE,eAAuB,EACvB,uBAA+B,EAC/B,oBAA4B,EAC5B,QAAyD;QAEzD,MAAM,aAAa,GAAG,IAAI,CAAC,sCAAsC,CAC/D,WAAW,EACX,eAAe,EACf,uBAAuB,EACvB,oBAAoB,CACrB,CAAC;QACF,MAAM,qBAAqB,GAAG,IAAI,CAAC,uCAAuC,CACxE,aAAa,EACb,YAAY,EACZ,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EACpB,QAAQ,CACT,CAAC;QACF,OAAO,MAAM,CAAC,OAAO,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC,CAAC;IACxD,CAAC;IAEO,sCAAsC,CAC5C,WAAkB,EAClB,eAAuB,EACvB,uBAA+B,EAC/B,oBAA4B;QAE5B,OAAO,WAAW,CAAC,MAAM,CACvB,CAAC,eAAe,EAAE,UAAU,EAAE,EAAE,CAC9B,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE;YAC7B,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,EAAE;gBAC7B,MAAM,EAAE,MAAM,CACZ;oBACE,QAAQ,EAAE,UAAU,CAAC,IAAI;oBACzB,WAAW,EAAE,UAAU,CAAC,uBAAuB,CAAC;oBAChD,QAAQ,EAAE,UAAU,CAAC,oBAAoB,CAAC;oBAC1C,OAAO,EAAE,UAAU,CAAC,GAAG;iBACxB,EACD,KAAK,CACN;gBACD,OAAO,EAAE,SAAS;aACnB;SACF,CAAC,EACJ,EAAE,CACH,CAAC;IACJ,CAAC;IAEO,uCAAuC,CAC7C,aAAqB,EACrB,YAAkE,EAClE,eAAuB,EACvB,uBAA+B,EAC/B,oBAA4B,EAC5B,QAAyD;QAEzD,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;YACjC,MAAM,iBAAiB,GAAqB;gBAC1C,OAAO,EAAE,MAAM,CACb;oBACE,QAAQ,EAAE,WAAW,CAAC,IAAI;oBAC1B,WAAW,EAAE,WAAW,CAAC,uBAAuB,CAAC;oBACjD,QAAQ,EAAE,WAAW,CAAC,oBAAoB,CAAC;oBAC3C,OAAO,EAAE,WAAW,CAAC,GAAG;iBACzB,EACD,KAAK,CACN;gBACD,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC;oBACjD,CAAC,CAAC,aAAa,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,MAAM;oBACpD,CAAC,CAAC,SAAS;aACd,CAAC;YACF,iBAAiB,CAAC,eAAe,GAAG,QAAQ,CAAC,iBAAiB,CAAC,CAAC;YAChE,aAAa,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,GAAG,iBAAiB,CAAC;QAClE,CAAC,CAAC,CAAC;QACH,OAAO,aAAa,CAAC;IACvB,CAAC;8GA1PU,oBAAoB;kHAApB,oBAAoB;;2FAApB,oBAAoB;kBADhC,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  IManagedObject,\n  InventoryService,\n  IOperation,\n  IResultList,\n  OperationService,\n  OperationStatus,\n  QueriesUtil\n} from '@c8y/client';\nimport { AlertService, gettext } from '@c8y/ngx-components';\nimport { get, isNil, omitBy, sortBy, toArray } from 'lodash-es';\nimport {\n  ComparisonResult,\n  DeviceProfile,\n  DeviceProfileFirmware,\n  DeviceProfileSoftware\n} from './device-profile.model';\n\n@Injectable()\nexport class DeviceProfileService {\n  readonly dateFrom = new Date(0);\n  readonly dateTo = new Date(Date.now() + 86400000); // 1 day in the future\n  private queriesUtil: QueriesUtil;\n\n  private NOT_INSTALLED_WARNING = gettext('Not installed on the device');\n  private VERSION_MISSMATCH_WARNING = gettext('Version mismatch');\n  private SAME_URL_WARNING = gettext(\n    'Installed configuration has the same URL but different name or type than the one in the profile'\n  );\n\n  constructor(\n    private inventoryService: InventoryService,\n    private operationService: OperationService,\n    private alertService: AlertService\n  ) {\n    this.queriesUtil = new QueriesUtil();\n  }\n\n  createDeviceProfile(deviceProfile: Partial<DeviceProfile>) {\n    if (get(deviceProfile, 'c8y_Filter.type') === '') {\n      delete deviceProfile.c8y_Filter.type;\n    }\n    return this.inventoryService.create(deviceProfile as IManagedObject);\n  }\n\n  getDeviceProfilesByDeviceType(deviceType: string): Promise<IResultList<IManagedObject>> {\n    const deviceTypeFilter = {\n      __or: [\n        { 'c8y_Filter.type': deviceType },\n        { 'c8y_Filter.type': '' },\n        { __not: { __has: 'c8y_Filter.type' } }\n      ]\n    };\n    return this.getDeviceProfiles(deviceTypeFilter);\n  }\n\n  getDeviceProfiles(andQuery?: any): Promise<IResultList<IManagedObject>> {\n    let query: object = {\n      type: 'c8y_Profile'\n    };\n    const filter: object = {\n      pageSize: 100,\n      withTotalPages: true\n    };\n    query = this.queriesUtil.addAndFilter(query, andQuery || {});\n    return this.inventoryService.listQuery(query, filter);\n  }\n\n  async getProfileOperation(deviceId: string | number) {\n    const filter: object = {\n      deviceId,\n      fragmentType: 'c8y_DeviceProfile',\n      dateFrom: this.dateFrom.toISOString(),\n      dateTo: this.dateTo.toISOString(),\n      revert: true,\n      pageSize: 1\n    };\n\n    const operation = (await this.operationService.list(filter)).data[0];\n    return operation && operation.status !== OperationStatus.SUCCESSFUL ? operation : undefined;\n  }\n\n  async createProfileOperation(device: IManagedObject, deviceProfile: Partial<DeviceProfile>) {\n    let operation;\n    const operationCfg: IOperation = {\n      deviceId: device.id,\n      profileId: deviceProfile.id,\n      profileName: deviceProfile.name,\n      c8y_DeviceProfile: deviceProfile.c8y_DeviceProfile,\n      description: `Assign device profile ${deviceProfile.name} to device ${device.name}`\n    };\n    try {\n      const { data } = await this.operationService.create(operationCfg);\n      operation = data;\n    } catch (ex) {\n      this.alertService.addServerFailure(ex);\n    }\n    return operation;\n  }\n\n  getFirmwareItems(\n    device: IManagedObject,\n    selectedProfile: Partial<DeviceProfile>\n  ): ComparisonResult[] {\n    const deviceFirmware = device.c8y_Firmware;\n    const profileFirmware = get(selectedProfile, 'c8y_DeviceProfile.firmware');\n    const deviceItems = [];\n    const profileItems = [];\n\n    if (deviceFirmware) {\n      deviceItems.push(deviceFirmware);\n    }\n    if (profileFirmware) {\n      profileItems.push(profileFirmware);\n    }\n    return this.createProfileComparison(\n      deviceItems,\n      profileItems,\n      'name',\n      'version',\n      null,\n      this.getAlert('firmware')\n    );\n  }\n\n  getSoftwareItems(\n    device: IManagedObject,\n    selectedProfile: Partial<DeviceProfile>\n  ): ComparisonResult[] {\n    const deviceSoftware = device.c8y_SoftwareList;\n    const profileSoftware = get(selectedProfile, 'c8y_DeviceProfile.software');\n    return this.createProfileComparison(\n      deviceSoftware,\n      profileSoftware,\n      'name',\n      'version',\n      'softwareType',\n      this.getAlert('software')\n    );\n  }\n\n  getConfigurationItems(\n    device: IManagedObject,\n    selectedProfile: Partial<DeviceProfile>\n  ): ComparisonResult[] {\n    const deviceConfiguration = [];\n    Object.keys(device).forEach(key => {\n      if (key.slice(0, 18) === 'c8y_Configuration_') {\n        deviceConfiguration.push(device[key]);\n      }\n    });\n    const profileConfiguration = get(selectedProfile, 'c8y_DeviceProfile.configuration');\n    return this.createProfileComparison(\n      deviceConfiguration,\n      profileConfiguration,\n      'url',\n      null,\n      'type',\n      this.getAlert('configuration')\n    );\n  }\n\n  private getAlert(itemType: string): (comparisionResult: ComparisonResult) => string {\n    const notInstalled = (comparisionResult: ComparisonResult) => {\n      return !comparisionResult.device ? this.NOT_INSTALLED_WARNING : '';\n    };\n\n    switch (itemType) {\n      case 'firmware':\n      case 'software':\n        return (comparisionResult: ComparisonResult) => {\n          return comparisionResult.device &&\n            comparisionResult.profile &&\n            comparisionResult.device.itemDetails !== comparisionResult.profile.itemDetails\n            ? this.VERSION_MISSMATCH_WARNING\n            : notInstalled(comparisionResult);\n        };\n      case 'configuration':\n        return (comparisionResult: ComparisonResult) => {\n          return comparisionResult.device &&\n            comparisionResult.profile &&\n            (comparisionResult.device.itemName !== comparisionResult.profile.itemName ||\n              comparisionResult.device.itemDetails !== comparisionResult.profile.itemDetails)\n            ? this.SAME_URL_WARNING\n            : notInstalled(comparisionResult);\n        };\n      default:\n        return notInstalled;\n    }\n  }\n\n  private createProfileComparison(\n    deviceItems: any[] = [],\n    profileItems: Array<DeviceProfileSoftware | DeviceProfileFirmware> = [],\n    mergeByProperty: string,\n    propertyNameWithDetails: string,\n    propertyNameWithType: string,\n    getAlert: (comparisionResult: ComparisonResult) => string\n  ): ComparisonResult[] {\n    const comparisonObj = this.createProfileComparisonFromDeviceItems(\n      deviceItems,\n      mergeByProperty,\n      propertyNameWithDetails,\n      propertyNameWithType\n    );\n    const extendedComparisonObj = this.extendProfileComparisonWithProfileItems(\n      comparisonObj,\n      profileItems,\n      mergeByProperty,\n      propertyNameWithDetails,\n      propertyNameWithType,\n      getAlert\n    );\n    return sortBy(toArray(extendedComparisonObj), 'name');\n  }\n\n  private createProfileComparisonFromDeviceItems(\n    deviceItems: any[],\n    mergeByProperty: string,\n    propertyNameWithDetails: string,\n    propertyNameWithType: string\n  ): any {\n    return deviceItems.reduce(\n      (comapritionItem, deviceItem) =>\n        Object.assign(comapritionItem, {\n          [deviceItem[mergeByProperty]]: {\n            device: omitBy(\n              {\n                itemName: deviceItem.name,\n                itemDetails: deviceItem[propertyNameWithDetails],\n                itemType: deviceItem[propertyNameWithType],\n                itemUrl: deviceItem.url\n              },\n              isNil\n            ),\n            profile: undefined\n          }\n        }),\n      {}\n    );\n  }\n\n  private extendProfileComparisonWithProfileItems(\n    comparisonObj: object,\n    profileItems: Array<DeviceProfileSoftware | DeviceProfileFirmware>,\n    mergeByProperty: string,\n    propertyNameWithDetails: string,\n    propertyNameWithType: string,\n    getAlert: (comparisionResult: ComparisonResult) => string\n  ) {\n    profileItems.forEach(profileItem => {\n      const comparisionResult: ComparisonResult = {\n        profile: omitBy(\n          {\n            itemName: profileItem.name,\n            itemDetails: profileItem[propertyNameWithDetails],\n            itemType: profileItem[propertyNameWithType],\n            itemUrl: profileItem.url\n          },\n          isNil\n        ),\n        device: comparisonObj[profileItem[mergeByProperty]]\n          ? comparisonObj[profileItem[mergeByProperty]].device\n          : undefined\n      };\n      comparisionResult.comparisonAlert = getAlert(comparisionResult);\n      comparisonObj[profileItem[mergeByProperty]] = comparisionResult;\n    });\n    return comparisonObj;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device-profile.service.js","sourceRoot":"","sources":["../../../device-profile/device-profile.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  IManagedObject,\n  InventoryService,\n  IOperation,\n  IResultList,\n  OperationService,\n  OperationStatus,\n  QueriesUtil\n} from '@c8y/client';\nimport { AlertService, gettext } from '@c8y/ngx-components';\nimport {\n  get,\n  isEmpty,\n  isNil,\n  keyBy,\n  keys,\n  mapValues,\n  omitBy,\n  pickBy,\n  sortBy,\n  toArray,\n  uniqBy\n} from 'lodash-es';\nimport {\n  ComparisonResult,\n  DeviceProfile,\n  DeviceProfileFirmware,\n  DeviceProfileSoftware\n} from './device-profile.model';\n\n@Injectable()\nexport class DeviceProfileService {\n  readonly dateFrom = new Date(0);\n  readonly dateTo = new Date(Date.now() + 86400000); // 1 day in the future\n  private queriesUtil: QueriesUtil;\n\n  private NOT_INSTALLED_WARNING = gettext('Not installed on the device');\n  private VERSION_MISSMATCH_WARNING = gettext('Version mismatch');\n  private SAME_URL_WARNING = gettext(\n    'Installed configuration has the same URL but different name or type than the one in the profile'\n  );\n\n  constructor(\n    private inventoryService: InventoryService,\n    private operationService: OperationService,\n    private alertService: AlertService\n  ) {\n    this.queriesUtil = new QueriesUtil();\n  }\n\n  createDeviceProfile(deviceProfile: Partial<DeviceProfile>) {\n    if (get(deviceProfile, 'c8y_Filter.type') === '') {\n      delete deviceProfile.c8y_Filter.type;\n    }\n    return this.inventoryService.create(deviceProfile as IManagedObject);\n  }\n\n  /**\n   * Determines the available device profiles for a given device by considering device type\n   * and the supported software types declared by the devices. Because of limitations in the\n   * Inventory Query API the methods return profile that contain at least one of the supported\n   * software types and omits profiles having only non-supported software types. Resulting device\n   * profiles need to be further filtered on the client side to exclude the ones that contain\n   * non-supported software types next to the supported ones.\n   *\n   * @param device A device MO\n   * @param name Optional device profile name filter\n   * @returns Candidate device profiles that contain at least on software with supported type.\n   */\n  getDeviceProfilesByDevice(\n    device: IManagedObject,\n    name: string = null\n  ): Promise<IResultList<IManagedObject>> {\n    const deviceTypeFilter = {\n      __or: [\n        { 'c8y_Filter.type': device.type },\n        { 'c8y_Filter.type': '' },\n        { __not: { __has: 'c8y_Filter.type' } }\n      ]\n    };\n\n    let softwareTypeFilter = {};\n    if (!isEmpty(device.c8y_SupportedSoftwareTypes)) {\n      softwareTypeFilter = {\n        __hasany: device.c8y_SupportedSoftwareTypes.map((type: string) => `softwareType!${type}`)\n      };\n    }\n    let query = this.queriesUtil.addAndFilter(deviceTypeFilter, softwareTypeFilter);\n\n    let profileNameFilter = {};\n    if (!isEmpty(name)) {\n      profileNameFilter = { name: `*${name}*` };\n    }\n    query = this.queriesUtil.addAndFilter(query, profileNameFilter);\n\n    return this.getDeviceProfiles(query);\n  }\n\n  /**\n   * @deprecated Use `getDeviceProfilesByDevice` instead as it also considers the supported software types.\n   */\n  getDeviceProfilesByDeviceType(deviceType: string): Promise<IResultList<IManagedObject>> {\n    const deviceTypeFilter = {\n      __or: [\n        { 'c8y_Filter.type': deviceType },\n        { 'c8y_Filter.type': '' },\n        { __not: { __has: 'c8y_Filter.type' } }\n      ]\n    };\n    return this.getDeviceProfiles(deviceTypeFilter);\n  }\n\n  getDeviceProfiles(andQuery?: any): Promise<IResultList<IManagedObject>> {\n    let query: object = {\n      type: 'c8y_Profile'\n    };\n    const filter: object = {\n      pageSize: 100,\n      withTotalPages: true\n    };\n    query = this.queriesUtil.addAndFilter(query, andQuery || {});\n    return this.inventoryService.listQuery(query, filter);\n  }\n\n  async getProfileOperation(deviceId: string | number) {\n    const filter: object = {\n      deviceId,\n      fragmentType: 'c8y_DeviceProfile',\n      dateFrom: this.dateFrom.toISOString(),\n      dateTo: this.dateTo.toISOString(),\n      revert: true,\n      pageSize: 1\n    };\n\n    const operation = (await this.operationService.list(filter)).data[0];\n    return operation && operation.status !== OperationStatus.SUCCESSFUL ? operation : undefined;\n  }\n\n  async createProfileOperation(device: IManagedObject, deviceProfile: Partial<DeviceProfile>) {\n    let operation;\n    const operationCfg: IOperation = {\n      deviceId: device.id,\n      profileId: deviceProfile.id,\n      profileName: deviceProfile.name,\n      c8y_DeviceProfile: deviceProfile.c8y_DeviceProfile,\n      description: `Assign device profile ${deviceProfile.name} to device ${device.name}`\n    };\n    try {\n      const { data } = await this.operationService.create(operationCfg);\n      operation = data;\n    } catch (ex) {\n      this.alertService.addServerFailure(ex);\n    }\n    return operation;\n  }\n\n  getFirmwareItems(\n    device: IManagedObject,\n    selectedProfile: Partial<DeviceProfile>\n  ): ComparisonResult[] {\n    const deviceFirmware = device.c8y_Firmware;\n    const profileFirmware = get(selectedProfile, 'c8y_DeviceProfile.firmware');\n    const deviceItems = [];\n    const profileItems = [];\n\n    if (deviceFirmware) {\n      deviceItems.push(deviceFirmware);\n    }\n    if (profileFirmware) {\n      profileItems.push(profileFirmware);\n    }\n    return this.createProfileComparison(\n      deviceItems,\n      profileItems,\n      'name',\n      'version',\n      null,\n      this.getAlert('firmware')\n    );\n  }\n\n  getSoftwareItems(\n    device: IManagedObject,\n    selectedProfile: Partial<DeviceProfile>\n  ): ComparisonResult[] {\n    const deviceSoftware = device.c8y_SoftwareList;\n    const profileSoftware = get(selectedProfile, 'c8y_DeviceProfile.software');\n    return this.createProfileComparison(\n      deviceSoftware,\n      profileSoftware,\n      'name',\n      'version',\n      'softwareType',\n      this.getAlert('software')\n    );\n  }\n\n  getConfigurationItems(\n    device: IManagedObject,\n    selectedProfile: Partial<DeviceProfile>\n  ): ComparisonResult[] {\n    const deviceConfiguration = [];\n    Object.keys(device).forEach(key => {\n      if (key.slice(0, 18) === 'c8y_Configuration_') {\n        deviceConfiguration.push(device[key]);\n      }\n    });\n    const profileConfiguration = get(selectedProfile, 'c8y_DeviceProfile.configuration');\n    return this.createProfileComparison(\n      deviceConfiguration,\n      profileConfiguration,\n      'url',\n      null,\n      'type',\n      this.getAlert('configuration')\n    );\n  }\n\n  /**\n   * Aligns device profile managed object's `softwareType!*` fragments to the software items\n   * included in the device profile. Removes obsolete software type fragments and adds new.\n   *\n   * @param profilePartial The device profile managed object which `softwareType!*` fragments will be adjusted.\n   * @returns The adjusted device profile managed object.\n   */\n  alignSoftwareTypeFragments(\n    profilePartial: Partial<DeviceProfile>,\n    profile: DeviceProfile\n  ): Partial<DeviceProfile> {\n    if (!profilePartial?.c8y_DeviceProfile?.software || !profile) {\n      return profilePartial;\n    }\n\n    const removedSoftwareTypes = mapValues(\n      omitBy(\n        profile,\n        (_: unknown, key: PropertyKey) =>\n          typeof key === 'string' && !key.startsWith('softwareType!')\n      ),\n      () => null\n    );\n    const softwareTypesToAdd: { [key: PropertyKey]: Record<PropertyKey, never> } = mapValues(\n      keyBy(\n        uniqBy(profilePartial.c8y_DeviceProfile.software, 'softwareType'),\n        (profile: DeviceProfileSoftware) => `softwareType!${profile.softwareType}`\n      ),\n      () => ({})\n    );\n\n    const result = { ...profilePartial, ...removedSoftwareTypes, ...softwareTypesToAdd };\n    return result;\n  }\n\n  getSoftwareTypes(profile: DeviceProfile): string[] {\n    return keys(\n      pickBy(\n        profile,\n        (_: unknown, key: PropertyKey) => typeof key === 'string' && key.startsWith('softwareType!')\n      )\n    ).map(softwareType => softwareType.substr('softwareType!'.length));\n  }\n\n  private getAlert(itemType: string): (comparisionResult: ComparisonResult) => string {\n    const notInstalled = (comparisionResult: ComparisonResult) => {\n      return !comparisionResult.device ? this.NOT_INSTALLED_WARNING : '';\n    };\n\n    switch (itemType) {\n      case 'firmware':\n      case 'software':\n        return (comparisionResult: ComparisonResult) => {\n          return comparisionResult.device &&\n            comparisionResult.profile &&\n            comparisionResult.device.itemDetails !== comparisionResult.profile.itemDetails\n            ? this.VERSION_MISSMATCH_WARNING\n            : notInstalled(comparisionResult);\n        };\n      case 'configuration':\n        return (comparisionResult: ComparisonResult) => {\n          return comparisionResult.device &&\n            comparisionResult.profile &&\n            (comparisionResult.device.itemName !== comparisionResult.profile.itemName ||\n              comparisionResult.device.itemDetails !== comparisionResult.profile.itemDetails)\n            ? this.SAME_URL_WARNING\n            : notInstalled(comparisionResult);\n        };\n      default:\n        return notInstalled;\n    }\n  }\n\n  private createProfileComparison(\n    deviceItems: any[] = [],\n    profileItems: Array<DeviceProfileSoftware | DeviceProfileFirmware> = [],\n    mergeByProperty: string,\n    propertyNameWithDetails: string,\n    propertyNameWithType: string,\n    getAlert: (comparisionResult: ComparisonResult) => string\n  ): ComparisonResult[] {\n    const comparisonObj = this.createProfileComparisonFromDeviceItems(\n      deviceItems,\n      mergeByProperty,\n      propertyNameWithDetails,\n      propertyNameWithType\n    );\n    const extendedComparisonObj = this.extendProfileComparisonWithProfileItems(\n      comparisonObj,\n      profileItems,\n      mergeByProperty,\n      propertyNameWithDetails,\n      propertyNameWithType,\n      getAlert\n    );\n    return sortBy(toArray(extendedComparisonObj), 'name');\n  }\n\n  private createProfileComparisonFromDeviceItems(\n    deviceItems: any[],\n    mergeByProperty: string,\n    propertyNameWithDetails: string,\n    propertyNameWithType: string\n  ): any {\n    return deviceItems.reduce(\n      (comapritionItem, deviceItem) =>\n        Object.assign(comapritionItem, {\n          [deviceItem[mergeByProperty]]: {\n            device: omitBy(\n              {\n                itemName: deviceItem.name,\n                itemDetails: deviceItem[propertyNameWithDetails],\n                itemType: deviceItem[propertyNameWithType],\n                itemUrl: deviceItem.url\n              },\n              isNil\n            ),\n            profile: undefined\n          }\n        }),\n      {}\n    );\n  }\n\n  private extendProfileComparisonWithProfileItems(\n    comparisonObj: object,\n    profileItems: Array<DeviceProfileSoftware | DeviceProfileFirmware>,\n    mergeByProperty: string,\n    propertyNameWithDetails: string,\n    propertyNameWithType: string,\n    getAlert: (comparisionResult: ComparisonResult) => string\n  ) {\n    profileItems.forEach(profileItem => {\n      const comparisionResult: ComparisonResult = {\n        profile: omitBy(\n          {\n            itemName: profileItem.name,\n            itemDetails: profileItem[propertyNameWithDetails],\n            itemType: profileItem[propertyNameWithType],\n            itemUrl: profileItem.url\n          },\n          isNil\n        ),\n        device: comparisonObj[profileItem[mergeByProperty]]\n          ? comparisonObj[profileItem[mergeByProperty]].device\n          : undefined\n      };\n      comparisionResult.comparisonAlert = getAlert(comparisionResult);\n      comparisonObj[profileItem[mergeByProperty]] = comparisionResult;\n    });\n    return comparisonObj;\n  }\n}\n"]}

package/esm2022/device-profile/device-tab-profile/device-tab-profile.component.mjs

@@ -1,9 +1,10 @@
-import { Component, forwardRef } from '@angular/core';
+import { Component, DestroyRef, forwardRef, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { ActivatedRoute } from '@angular/router';
 import { AlertService, gettext, ManagedObjectRealtimeService, OperationRealtimeService, PRODUCT_EXPERIENCE_EVENT_SOURCE } from '@c8y/ngx-components';
 import { has, pickBy } from 'lodash-es';
-import { pipe } from 'rxjs';
-import { filter, map } from 'rxjs/operators';
+import { BehaviorSubject, combineLatest, pipe } from 'rxjs';
+import { filter, map, switchMap, tap } from 'rxjs/operators';
 import { PRODUCT_EXPERIENCE_DEVICE_PROFILE } from '../device-profile.model';
 import { DeviceProfileService } from '../device-profile.service';
 import * as i0 from "@angular/core";
@@ -25,31 +26,43 @@ export class DeviceTabProfileComponent {
         this.firmwareItems = [];
         this.softwareItems = [];
         this.configurationItems = [];
-        this.pattern = '';
-        this.reloading = false;
+        this.pattern$ = new BehaviorSubject('');
+        this.reload$ = new BehaviorSubject(true);
         this.productExperienceEvent = {
             eventName: PRODUCT_EXPERIENCE_DEVICE_PROFILE.EVENTS.DEVICE_TAB,
             data: {
                 component: PRODUCT_EXPERIENCE_DEVICE_PROFILE.COMPONENTS.DEVICE_TAB_PROFILE
             }
         };
+        this.destroyRef = inject(DestroyRef);
+        this.device = this.route.snapshot.parent.data.contextData;
     }
     async ngOnInit() {
-        this.device = this.route.snapshot.parent.data.contextData;
         this.getDeviceProfilesAndUpdateProfileItems();
         this.subscribeToManagedObjects();
+        const supportedSoftwareTypes = new Set(this.device.c8y_SupportedSoftwareTypes);
+        const isSubset = (profileTypes) => {
+            return profileTypes.every(type => supportedSoftwareTypes.has(type));
+        };
+        this.filterPipe = pipe(map(data => {
+            if (supportedSoftwareTypes.size) {
+                return data.filter(mo => isSubset(this.deviceProfileService.getSoftwareTypes(mo)));
+            }
+            else {
+                return data;
+            }
+        }));
     }
     async getDeviceProfilesAndUpdateProfileItems() {
-        this.reloading = true;
-        this.deviceProfiles = await this.deviceProfileService.getDeviceProfilesByDeviceType(this.device.type);
-        if (this.device.c8y_Profile) {
-            const profileId = this.device.c8y_Profile.profileId;
-            this.selectedProfile = this.deviceProfiles.data.find(mo => mo.id === profileId);
-        }
-        this.updateProfileItems(this.device, this.selectedProfile);
-        this.operation = await this.deviceProfileService.getProfileOperation(this.device.id);
-        this.subscribeToOperations();
-        this.reloading = false;
+        this.deviceProfiles$ = combineLatest([this.reload$.pipe(filter(Boolean)), this.pattern$]).pipe(switchMap(([_, name]) => this.deviceProfileService.getDeviceProfilesByDevice(this.device, name)), tap(async (profiles) => {
+            if (this.device.c8y_Profile) {
+                const profileId = this.device.c8y_Profile.profileId;
+                this.selectedProfile = profiles.data.find(mo => mo.id === profileId);
+            }
+            this.updateProfileItems(this.device, this.selectedProfile);
+            this.operation = await this.deviceProfileService.getProfileOperation(this.device.id);
+            this.subscribeToOperations();
+        }), tap(() => this.reload$.next(false)), takeUntilDestroyed(this.destroyRef));
     }
     selectProfile(mo) {
         this.selectedProfile = this.toProfileForDevice(mo);
@@ -58,37 +71,30 @@ export class DeviceTabProfileComponent {
     async createOperation() {
         this.operation = await this.deviceProfileService.createProfileOperation(this.device, this.selectedProfile);
     }
-    setPipe(filterStr) {
-        this.pattern = filterStr;
-        this.filterPipe = pipe(map(data => {
-            return data.filter(mo => mo.name && mo.name.toLowerCase().indexOf(filterStr.toLowerCase()) > -1);
-        }));
-    }
-    ngOnDestroy() {
-        this.operationsSubscription.unsubscribe();
-        this.moOnUpdateSubscription.unsubscribe();
-        this.moOnDeleteSubscription.unsubscribe();
-    }
     updateProfileItems(device, profile) {
         this.firmwareItems = this.deviceProfileService.getFirmwareItems(device, profile);
         this.softwareItems = this.deviceProfileService.getSoftwareItems(device, profile);
         this.configurationItems = this.deviceProfileService.getConfigurationItems(device, profile);
     }
     subscribeToManagedObjects() {
-        this.moOnUpdateSubscription = this.deviceRealtime
+        this.deviceRealtime
             .onUpdate$(this.device.id)
+            .pipe(takeUntilDestroyed(this.destroyRef))
             .subscribe((managedObject) => {
             this.updateProfileItems(managedObject, this.selectedProfile);
         });
-        this.moOnDeleteSubscription = this.deviceRealtime.onDelete$(this.device.id).subscribe(() => {
+        this.deviceRealtime
+            .onDelete$(this.device.id)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
             this.alertService.danger(gettext('This device has just been deleted. You will be redirected to "All devices" page now.'));
             window.location.href = '#/device';
         });
     }
     subscribeToOperations() {
-        this.operationsSubscription = this.operationRealtime
+        this.operationRealtime
             .onAll$(this.device.id)
-            .pipe(map(({ data }) => data), filter(operation => operation.c8y_DeviceProfile))
+            .pipe(map(({ data }) => data), filter(operation => operation.c8y_DeviceProfile), takeUntilDestroyed(this.destroyRef))
             .subscribe(operation => {
             this.operation = operation;
         });
@@ -115,7 +121,7 @@ export class DeviceTabProfileComponent {
                 provide: PRODUCT_EXPERIENCE_EVENT_SOURCE,
                 useExisting: forwardRef(() => DeviceTabProfileComponent)
             }
-        ], ngImport: i0, template: "<c8y-action-bar-item [placement]=\"'right'\">\n  <button\n    class=\"btn btn-link\"\n    title=\"{{ 'Reload' | translate }}\"\n    type=\"button\"\n    (click)=\"getDeviceProfilesAndUpdateProfileItems()\"\n  >\n    <i\n      c8yIcon=\"refresh\"\n      [ngClass]=\"{ 'icon-spin': reloading }\"\n    ></i>\n    {{ 'Reload' | translate }}\n  </button>\n</c8y-action-bar-item>\n<c8y-action-bar-item [placement]=\"'right'\">\n  <c8y-realtime-btn [service]=\"deviceRealtime\"></c8y-realtime-btn>\n</c8y-action-bar-item>\n\n<div class=\"card card--grid--fullpage card--grid--fullpage card--grid grid__row--2-10--md\">\n  <div class=\"card--grid grid__col--6-6--md\">\n    <!-- AVAILABLE PROFILES -->\n    <div class=\"bg-level-0\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Device profile\n        </div>\n      </div>\n      <div class=\"p-16\">\n        <form #deviceProfileForm=\"ngForm\">\n          <div class=\"input-group\">\n            <c8y-typeahead\n              class=\"flex-grow\"\n              placeholder=\"{{ 'Select device profile' | translate }}\"\n              name=\"selectProfile\"\n              data-cy=\"device-tab-profile--select-device-profile\"\n              [(ngModel)]=\"selectedProfile\"\n              (onSearch)=\"setPipe($event)\"\n              [allowFreeEntries]=\"false\"\n            >\n              <c8y-li\n                class=\"p-l-8 p-r-8 c8y-list__item--link\"\n                *c8yFor=\"let profile of deviceProfiles; pipe: filterPipe\"\n                (click)=\"selectProfile(profile); setPipe('')\"\n              >\n                <c8y-highlight\n                  [text]=\"profile.name || '&#45;&#45;'\"\n                  [pattern]=\"pattern\"\n                ></c8y-highlight>\n              </c8y-li>\n            </c8y-typeahead>\n            <div class=\"input-group-btn\">\n              <button\n                class=\"btn btn-primary\"\n                title=\"{{ 'Assign device profile' | translate }}\"\n                type=\"button\"\n                (click)=\"createOperation()\"\n                data-cy=\"device-tab-profile--Assign-device-profile-button\"\n                [disabled]=\"!selectedProfile?.id\"\n                c8yProductExperience\n                inherit\n                [actionData]=\"{ action: PRODUCT_EXPERIENCE.ACTIONS.ASSIGN_DEVICE_PROFILE }\"\n              >\n                <span>{{ 'Assign device profile' | translate }}</span>\n              </button>\n            </div>\n          </div>\n        </form>\n      </div>\n    </div>\n\n    <!-- INSTALL PROFILE OPERATION -->\n    <div class=\"bg-level-1\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Currently installed\n        </div>\n      </div>\n      <div class=\"card-block\">\n        <c8y-operation-details\n          [operation]=\"operation\"\n          c8yProductExperience\n          inherit\n          suppressDataOverriding\n        ></c8y-operation-details>\n      </div>\n    </div>\n  </div>\n  <div class=\"card--grid__inner-scroll d-col no-align-items\">\n    <div class=\"d-contents\">\n      <!-- FIRMWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-firmware'\"\n        [sectionTitle]=\"'Firmware' | translate\"\n        [emptyStateText]=\"'No firmware to display.' | translate\"\n        [emptyStateDetails]=\"'No firmware assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"firmwareItems\"\n        [isEmpty]=\"!selectedProfile?.c8y_DeviceProfile?.firmware?.name\"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- SOFTWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-tools'\"\n        [sectionTitle]=\"'Software' | translate\"\n        [emptyStateText]=\"'No software to display.' | translate\"\n        [emptyStateDetails]=\"'No software assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"softwareItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.software ||\n          selectedProfile?.c8y_DeviceProfile?.software?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- CONFIGURATION -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'gears'\"\n        [sectionTitle]=\"'Configuration' | translate\"\n        [emptyStateText]=\"'No configuration to display' | translate\"\n        [emptyStateDetails]=\"'No configuration assigned' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"configurationItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.configuration ||\n          selectedProfile?.c8y_DeviceProfile?.configuration?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <!-- fill in the remanining vertical space when empty -->\n    <div class=\"card--grid grid__col--6-6--md flex-grow\">\n      <div class=\"bg-level-0\"></div>\n      <div class=\"bg-level-1\"></div>\n    </div>\n  </div>\n</div>\n", dependencies: [{ kind: "component", type: i1.ActionBarItemComponent, selector: "c8y-action-bar-item", inputs: ["placement", "priority", "itemClass", "injector", "groupId", "inGroupPriority"] }, { kind: "directive", type: i1.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "directive", type: i1.C8yTranslateDirective, selector: "[translate],[ngx-translate]" }, { kind: "directive", type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.ForOfDirective, selector: "[c8yFor]", inputs: ["c8yForOf", "c8yForLoadMore", "c8yForPipe", "c8yForNotFound", "c8yForMaxIterations", "c8yForLoadingTemplate", "c8yForLoadNextLabel", "c8yForLoadingLabel", "c8yForRealtime", "c8yForRealtimeOptions", "c8yForComparator", "c8yForEnableVirtualScroll", "c8yForVirtualScrollElementSize", "c8yForVirtualScrollStrategy", "c8yForVirtualScrollContainerHeight"], outputs: ["c8yForCount", "c8yForChange", "c8yForLoadMoreComponent"] }, { kind: "component", type: i1.HighlightComponent, selector: "c8y-highlight", inputs: ["pattern", "text", "elementClass", "shouldTrimPattern"] }, { kind: "component", type: i1.TypeaheadComponent, selector: "c8y-typeahead", inputs: ["required", "maxlength", "disabled", "allowFreeEntries", "placeholder", "displayProperty", "icon", "name", "autoClose", "hideNew", "container", "selected", "highlightFirstItem"], outputs: ["onSearch", "onIconClick"] }, { kind: "directive", type: i5.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i5.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i1.ListItemComponent, selector: "c8y-list-item, c8y-li", inputs: ["active", "highlighted", "emptyActions", "dense", "collapsed", "selectable"], outputs: ["collapsedChange"] }, { kind: "directive", type: i1.ProductExperienceDirective, selector: "[c8yProductExperience]", inputs: ["actionName", "actionData", "inherit", "suppressDataOverriding"] }, { kind: "component", type: i1.RealtimeButtonComponent, selector: "c8y-realtime-btn", inputs: ["service", "label", "title", "disabled"], outputs: ["onToggle"] }, { kind: "component", type: i6.OperationDetailsComponent, selector: "c8y-operation-details", inputs: ["operation"] }, { kind: "component", type: i7.DeviceTabProfileDetailComponent, selector: "c8y-device-tab-profile-detail", inputs: ["sectionTitle", "sectionIcon", "emptyStateText", "emptyStateDetails", "isProfileSelected", "isEmpty", "items", "showTextLabel"] }, { kind: "pipe", type: i1.C8yTranslatePipe, name: "translate" }] }); }
+        ], ngImport: i0, template: "<c8y-action-bar-item [placement]=\"'right'\">\n  <button\n    class=\"btn btn-link\"\n    title=\"{{ 'Reload' | translate }}\"\n    type=\"button\"\n    (click)=\"reload$.next(true)\"\n  >\n    <i\n      c8yIcon=\"refresh\"\n      [ngClass]=\"{ 'icon-spin': reload$.value }\"\n    ></i>\n    {{ 'Reload' | translate }}\n  </button>\n</c8y-action-bar-item>\n<c8y-action-bar-item [placement]=\"'right'\">\n  <c8y-realtime-btn [service]=\"deviceRealtime\"></c8y-realtime-btn>\n</c8y-action-bar-item>\n\n<div class=\"card card--grid--fullpage card--grid--fullpage card--grid grid__row--2-10--md\">\n  <div class=\"card--grid grid__col--6-6--md\">\n    <!-- AVAILABLE PROFILES -->\n    <div class=\"bg-level-0\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Device profile\n        </div>\n      </div>\n      <div class=\"p-16\">\n        <form #deviceProfileForm=\"ngForm\">\n          <div class=\"input-group\">\n            <c8y-typeahead\n              class=\"flex-grow\"\n              placeholder=\"{{ 'Select device profile' | translate }}\"\n              name=\"selectProfile\"\n              data-cy=\"device-tab-profile--select-device-profile\"\n              [(ngModel)]=\"selectedProfile\"\n              (onSearch)=\"pattern$.next($event)\"\n              [allowFreeEntries]=\"false\"\n            >\n              <c8y-li\n                class=\"p-l-8 p-r-8 c8y-list__item--link\"\n                *c8yFor=\"let profile of deviceProfiles$; pipe: filterPipe\"\n                (click)=\"selectProfile(profile); pattern$.next('')\"\n              >\n                <c8y-highlight\n                  [text]=\"profile.name || '&#45;&#45;'\"\n                  [pattern]=\"pattern$.value\"\n                ></c8y-highlight>\n              </c8y-li>\n            </c8y-typeahead>\n            <div class=\"input-group-btn\">\n              <button\n                class=\"btn btn-primary\"\n                title=\"{{ 'Assign device profile' | translate }}\"\n                type=\"button\"\n                (click)=\"createOperation()\"\n                data-cy=\"device-tab-profile--Assign-device-profile-button\"\n                [disabled]=\"!selectedProfile?.id\"\n                c8yProductExperience\n                inherit\n                [actionData]=\"{ action: PRODUCT_EXPERIENCE.ACTIONS.ASSIGN_DEVICE_PROFILE }\"\n              >\n                <span>{{ 'Assign device profile' | translate }}</span>\n              </button>\n            </div>\n          </div>\n        </form>\n      </div>\n    </div>\n\n    <!-- INSTALL PROFILE OPERATION -->\n    <div class=\"bg-level-1\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Currently installed\n        </div>\n      </div>\n      <div class=\"card-block\">\n        <c8y-operation-details\n          [operation]=\"operation\"\n          c8yProductExperience\n          inherit\n          suppressDataOverriding\n        ></c8y-operation-details>\n      </div>\n    </div>\n  </div>\n  <div class=\"card--grid__inner-scroll d-col no-align-items\">\n    <div class=\"d-contents\">\n      <!-- FIRMWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-firmware'\"\n        [sectionTitle]=\"'Firmware' | translate\"\n        [emptyStateText]=\"'No firmware to display.' | translate\"\n        [emptyStateDetails]=\"'No firmware assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"firmwareItems\"\n        [isEmpty]=\"!selectedProfile?.c8y_DeviceProfile?.firmware?.name\"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- SOFTWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-tools'\"\n        [sectionTitle]=\"'Software' | translate\"\n        [emptyStateText]=\"'No software to display.' | translate\"\n        [emptyStateDetails]=\"'No software assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"softwareItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.software ||\n          selectedProfile?.c8y_DeviceProfile?.software?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- CONFIGURATION -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'gears'\"\n        [sectionTitle]=\"'Configuration' | translate\"\n        [emptyStateText]=\"'No configuration to display' | translate\"\n        [emptyStateDetails]=\"'No configuration assigned' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"configurationItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.configuration ||\n          selectedProfile?.c8y_DeviceProfile?.configuration?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <!-- fill in the remanining vertical space when empty -->\n    <div class=\"card--grid grid__col--6-6--md flex-grow\">\n      <div class=\"bg-level-0\"></div>\n      <div class=\"bg-level-1\"></div>\n    </div>\n  </div>\n</div>\n", dependencies: [{ kind: "component", type: i1.ActionBarItemComponent, selector: "c8y-action-bar-item", inputs: ["placement", "priority", "itemClass", "injector", "groupId", "inGroupPriority"] }, { kind: "directive", type: i1.IconDirective, selector: "[c8yIcon]", inputs: ["c8yIcon"] }, { kind: "directive", type: i1.C8yTranslateDirective, selector: "[translate],[ngx-translate]" }, { kind: "directive", type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.ForOfDirective, selector: "[c8yFor]", inputs: ["c8yForOf", "c8yForLoadMore", "c8yForPipe", "c8yForNotFound", "c8yForMaxIterations", "c8yForLoadingTemplate", "c8yForLoadNextLabel", "c8yForLoadingLabel", "c8yForRealtime", "c8yForRealtimeOptions", "c8yForComparator", "c8yForEnableVirtualScroll", "c8yForVirtualScrollElementSize", "c8yForVirtualScrollStrategy", "c8yForVirtualScrollContainerHeight"], outputs: ["c8yForCount", "c8yForChange", "c8yForLoadMoreComponent"] }, { kind: "component", type: i1.HighlightComponent, selector: "c8y-highlight", inputs: ["pattern", "text", "elementClass", "shouldTrimPattern"] }, { kind: "component", type: i1.TypeaheadComponent, selector: "c8y-typeahead", inputs: ["required", "maxlength", "disabled", "allowFreeEntries", "placeholder", "displayProperty", "icon", "name", "autoClose", "hideNew", "container", "selected", "highlightFirstItem"], outputs: ["onSearch", "onIconClick"] }, { kind: "directive", type: i5.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i5.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i1.ListItemComponent, selector: "c8y-list-item, c8y-li", inputs: ["active", "highlighted", "emptyActions", "dense", "collapsed", "selectable"], outputs: ["collapsedChange"] }, { kind: "directive", type: i1.ProductExperienceDirective, selector: "[c8yProductExperience]", inputs: ["actionName", "actionData", "inherit", "suppressDataOverriding"] }, { kind: "component", type: i1.RealtimeButtonComponent, selector: "c8y-realtime-btn", inputs: ["service", "label", "title", "disabled"], outputs: ["onToggle"] }, { kind: "component", type: i6.OperationDetailsComponent, selector: "c8y-operation-details", inputs: ["operation"] }, { kind: "component", type: i7.DeviceTabProfileDetailComponent, selector: "c8y-device-tab-profile-detail", inputs: ["sectionTitle", "sectionIcon", "emptyStateText", "emptyStateDetails", "isProfileSelected", "isEmpty", "items", "showTextLabel"] }, { kind: "pipe", type: i1.C8yTranslatePipe, name: "translate" }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DeviceTabProfileComponent, decorators: [{
             type: Component,
@@ -125,6 +131,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImpor
                             provide: PRODUCT_EXPERIENCE_EVENT_SOURCE,
                             useExisting: forwardRef(() => DeviceTabProfileComponent)
                         }
-                    ], template: "<c8y-action-bar-item [placement]=\"'right'\">\n  <button\n    class=\"btn btn-link\"\n    title=\"{{ 'Reload' | translate }}\"\n    type=\"button\"\n    (click)=\"getDeviceProfilesAndUpdateProfileItems()\"\n  >\n    <i\n      c8yIcon=\"refresh\"\n      [ngClass]=\"{ 'icon-spin': reloading }\"\n    ></i>\n    {{ 'Reload' | translate }}\n  </button>\n</c8y-action-bar-item>\n<c8y-action-bar-item [placement]=\"'right'\">\n  <c8y-realtime-btn [service]=\"deviceRealtime\"></c8y-realtime-btn>\n</c8y-action-bar-item>\n\n<div class=\"card card--grid--fullpage card--grid--fullpage card--grid grid__row--2-10--md\">\n  <div class=\"card--grid grid__col--6-6--md\">\n    <!-- AVAILABLE PROFILES -->\n    <div class=\"bg-level-0\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Device profile\n        </div>\n      </div>\n      <div class=\"p-16\">\n        <form #deviceProfileForm=\"ngForm\">\n          <div class=\"input-group\">\n            <c8y-typeahead\n              class=\"flex-grow\"\n              placeholder=\"{{ 'Select device profile' | translate }}\"\n              name=\"selectProfile\"\n              data-cy=\"device-tab-profile--select-device-profile\"\n              [(ngModel)]=\"selectedProfile\"\n              (onSearch)=\"setPipe($event)\"\n              [allowFreeEntries]=\"false\"\n            >\n              <c8y-li\n                class=\"p-l-8 p-r-8 c8y-list__item--link\"\n                *c8yFor=\"let profile of deviceProfiles; pipe: filterPipe\"\n                (click)=\"selectProfile(profile); setPipe('')\"\n              >\n                <c8y-highlight\n                  [text]=\"profile.name || '&#45;&#45;'\"\n                  [pattern]=\"pattern\"\n                ></c8y-highlight>\n              </c8y-li>\n            </c8y-typeahead>\n            <div class=\"input-group-btn\">\n              <button\n                class=\"btn btn-primary\"\n                title=\"{{ 'Assign device profile' | translate }}\"\n                type=\"button\"\n                (click)=\"createOperation()\"\n                data-cy=\"device-tab-profile--Assign-device-profile-button\"\n                [disabled]=\"!selectedProfile?.id\"\n                c8yProductExperience\n                inherit\n                [actionData]=\"{ action: PRODUCT_EXPERIENCE.ACTIONS.ASSIGN_DEVICE_PROFILE }\"\n              >\n                <span>{{ 'Assign device profile' | translate }}</span>\n              </button>\n            </div>\n          </div>\n        </form>\n      </div>\n    </div>\n\n    <!-- INSTALL PROFILE OPERATION -->\n    <div class=\"bg-level-1\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Currently installed\n        </div>\n      </div>\n      <div class=\"card-block\">\n        <c8y-operation-details\n          [operation]=\"operation\"\n          c8yProductExperience\n          inherit\n          suppressDataOverriding\n        ></c8y-operation-details>\n      </div>\n    </div>\n  </div>\n  <div class=\"card--grid__inner-scroll d-col no-align-items\">\n    <div class=\"d-contents\">\n      <!-- FIRMWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-firmware'\"\n        [sectionTitle]=\"'Firmware' | translate\"\n        [emptyStateText]=\"'No firmware to display.' | translate\"\n        [emptyStateDetails]=\"'No firmware assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"firmwareItems\"\n        [isEmpty]=\"!selectedProfile?.c8y_DeviceProfile?.firmware?.name\"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- SOFTWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-tools'\"\n        [sectionTitle]=\"'Software' | translate\"\n        [emptyStateText]=\"'No software to display.' | translate\"\n        [emptyStateDetails]=\"'No software assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"softwareItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.software ||\n          selectedProfile?.c8y_DeviceProfile?.software?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- CONFIGURATION -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'gears'\"\n        [sectionTitle]=\"'Configuration' | translate\"\n        [emptyStateText]=\"'No configuration to display' | translate\"\n        [emptyStateDetails]=\"'No configuration assigned' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"configurationItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.configuration ||\n          selectedProfile?.c8y_DeviceProfile?.configuration?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <!-- fill in the remanining vertical space when empty -->\n    <div class=\"card--grid grid__col--6-6--md flex-grow\">\n      <div class=\"bg-level-0\"></div>\n      <div class=\"bg-level-1\"></div>\n    </div>\n  </div>\n</div>\n" }]
+                    ], template: "<c8y-action-bar-item [placement]=\"'right'\">\n  <button\n    class=\"btn btn-link\"\n    title=\"{{ 'Reload' | translate }}\"\n    type=\"button\"\n    (click)=\"reload$.next(true)\"\n  >\n    <i\n      c8yIcon=\"refresh\"\n      [ngClass]=\"{ 'icon-spin': reload$.value }\"\n    ></i>\n    {{ 'Reload' | translate }}\n  </button>\n</c8y-action-bar-item>\n<c8y-action-bar-item [placement]=\"'right'\">\n  <c8y-realtime-btn [service]=\"deviceRealtime\"></c8y-realtime-btn>\n</c8y-action-bar-item>\n\n<div class=\"card card--grid--fullpage card--grid--fullpage card--grid grid__row--2-10--md\">\n  <div class=\"card--grid grid__col--6-6--md\">\n    <!-- AVAILABLE PROFILES -->\n    <div class=\"bg-level-0\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Device profile\n        </div>\n      </div>\n      <div class=\"p-16\">\n        <form #deviceProfileForm=\"ngForm\">\n          <div class=\"input-group\">\n            <c8y-typeahead\n              class=\"flex-grow\"\n              placeholder=\"{{ 'Select device profile' | translate }}\"\n              name=\"selectProfile\"\n              data-cy=\"device-tab-profile--select-device-profile\"\n              [(ngModel)]=\"selectedProfile\"\n              (onSearch)=\"pattern$.next($event)\"\n              [allowFreeEntries]=\"false\"\n            >\n              <c8y-li\n                class=\"p-l-8 p-r-8 c8y-list__item--link\"\n                *c8yFor=\"let profile of deviceProfiles$; pipe: filterPipe\"\n                (click)=\"selectProfile(profile); pattern$.next('')\"\n              >\n                <c8y-highlight\n                  [text]=\"profile.name || '&#45;&#45;'\"\n                  [pattern]=\"pattern$.value\"\n                ></c8y-highlight>\n              </c8y-li>\n            </c8y-typeahead>\n            <div class=\"input-group-btn\">\n              <button\n                class=\"btn btn-primary\"\n                title=\"{{ 'Assign device profile' | translate }}\"\n                type=\"button\"\n                (click)=\"createOperation()\"\n                data-cy=\"device-tab-profile--Assign-device-profile-button\"\n                [disabled]=\"!selectedProfile?.id\"\n                c8yProductExperience\n                inherit\n                [actionData]=\"{ action: PRODUCT_EXPERIENCE.ACTIONS.ASSIGN_DEVICE_PROFILE }\"\n              >\n                <span>{{ 'Assign device profile' | translate }}</span>\n              </button>\n            </div>\n          </div>\n        </form>\n      </div>\n    </div>\n\n    <!-- INSTALL PROFILE OPERATION -->\n    <div class=\"bg-level-1\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Currently installed\n        </div>\n      </div>\n      <div class=\"card-block\">\n        <c8y-operation-details\n          [operation]=\"operation\"\n          c8yProductExperience\n          inherit\n          suppressDataOverriding\n        ></c8y-operation-details>\n      </div>\n    </div>\n  </div>\n  <div class=\"card--grid__inner-scroll d-col no-align-items\">\n    <div class=\"d-contents\">\n      <!-- FIRMWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-firmware'\"\n        [sectionTitle]=\"'Firmware' | translate\"\n        [emptyStateText]=\"'No firmware to display.' | translate\"\n        [emptyStateDetails]=\"'No firmware assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"firmwareItems\"\n        [isEmpty]=\"!selectedProfile?.c8y_DeviceProfile?.firmware?.name\"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- SOFTWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-tools'\"\n        [sectionTitle]=\"'Software' | translate\"\n        [emptyStateText]=\"'No software to display.' | translate\"\n        [emptyStateDetails]=\"'No software assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"softwareItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.software ||\n          selectedProfile?.c8y_DeviceProfile?.software?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- CONFIGURATION -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'gears'\"\n        [sectionTitle]=\"'Configuration' | translate\"\n        [emptyStateText]=\"'No configuration to display' | translate\"\n        [emptyStateDetails]=\"'No configuration assigned' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"configurationItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.configuration ||\n          selectedProfile?.c8y_DeviceProfile?.configuration?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <!-- fill in the remanining vertical space when empty -->\n    <div class=\"card--grid grid__col--6-6--md flex-grow\">\n      <div class=\"bg-level-0\"></div>\n      <div class=\"bg-level-1\"></div>\n    </div>\n  </div>\n</div>\n" }]
         }], ctorParameters: () => [{ type: i1.ManagedObjectRealtimeService }, { type: i2.DeviceProfileService }, { type: i3.ActivatedRoute }, { type: i1.OperationRealtimeService }, { type: i1.AlertService }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device-tab-profile.component.js","sourceRoot":"","sources":["../../../../device-profile/device-tab-profile/device-tab-profile.component.ts","../../../../device-profile/device-tab-profile/device-tab-profile.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, forwardRef, OnDestroy, OnInit } from '@angular/core';\nimport { ActivatedRoute } from '@angular/router';\nimport { IManagedObject, IOperation, IResultList } from '@c8y/client';\nimport {\n  AlertService,\n  ForOfFilterPipe,\n  gettext,\n  ManagedObjectRealtimeService,\n  OperationRealtimeService,\n  PRODUCT_EXPERIENCE_EVENT_SOURCE,\n  ProductExperienceEvent,\n  ProductExperienceEventSource\n} from '@c8y/ngx-components';\nimport { has, pickBy } from 'lodash-es';\nimport { pipe, Subscription } from 'rxjs';\nimport { filter, map } from 'rxjs/operators';\nimport {\n  ComparisonResult,\n  DeviceProfile,\n  PRODUCT_EXPERIENCE_DEVICE_PROFILE\n} from '../device-profile.model';\nimport { DeviceProfileService } from '../device-profile.service';\n\n@Component({\n  selector: 'c8y-device-tab-profile',\n  templateUrl: './device-tab-profile.component.html',\n  providers: [\n    ManagedObjectRealtimeService,\n    {\n      provide: PRODUCT_EXPERIENCE_EVENT_SOURCE,\n      useExisting: forwardRef(() => DeviceTabProfileComponent)\n    }\n  ]\n})\nexport class DeviceTabProfileComponent implements OnInit, OnDestroy, ProductExperienceEventSource {\n  PRODUCT_EXPERIENCE = PRODUCT_EXPERIENCE_DEVICE_PROFILE;\n  device: IManagedObject;\n  deviceProfiles: IResultList<IManagedObject>;\n  selectedProfile: Partial<DeviceProfile>;\n  operation: IOperation;\n  firmwareItems: ComparisonResult[] = [];\n  softwareItems: ComparisonResult[] = [];\n  configurationItems: ComparisonResult[] = [];\n\n  filterPipe: ForOfFilterPipe;\n  pattern = '';\n  reloading = false;\n  productExperienceEvent: ProductExperienceEvent = {\n    eventName: PRODUCT_EXPERIENCE_DEVICE_PROFILE.EVENTS.DEVICE_TAB,\n    data: {\n      component: PRODUCT_EXPERIENCE_DEVICE_PROFILE.COMPONENTS.DEVICE_TAB_PROFILE\n    }\n  };\n  private operationsSubscription: Subscription;\n  private moOnDeleteSubscription: Subscription;\n  private moOnUpdateSubscription: Subscription;\n\n  constructor(\n    public deviceRealtime: ManagedObjectRealtimeService,\n    private deviceProfileService: DeviceProfileService,\n    private route: ActivatedRoute,\n    private operationRealtime: OperationRealtimeService,\n    private alertService: AlertService\n  ) {}\n\n  async ngOnInit() {\n    this.device = this.route.snapshot.parent.data.contextData;\n    this.getDeviceProfilesAndUpdateProfileItems();\n    this.subscribeToManagedObjects();\n  }\n\n  async getDeviceProfilesAndUpdateProfileItems() {\n    this.reloading = true;\n    this.deviceProfiles = await this.deviceProfileService.getDeviceProfilesByDeviceType(\n      this.device.type\n    );\n    if (this.device.c8y_Profile) {\n      const profileId = this.device.c8y_Profile.profileId;\n      this.selectedProfile = this.deviceProfiles.data.find(mo => mo.id === profileId);\n    }\n    this.updateProfileItems(this.device, this.selectedProfile);\n    this.operation = await this.deviceProfileService.getProfileOperation(this.device.id);\n    this.subscribeToOperations();\n    this.reloading = false;\n  }\n\n  selectProfile(mo: DeviceProfile) {\n    this.selectedProfile = this.toProfileForDevice(mo);\n    this.updateProfileItems(this.device, this.selectedProfile);\n  }\n\n  async createOperation() {\n    this.operation = await this.deviceProfileService.createProfileOperation(\n      this.device,\n      this.selectedProfile\n    );\n  }\n\n  setPipe(filterStr: string) {\n    this.pattern = filterStr;\n    this.filterPipe = pipe(\n      map(data => {\n        return data.filter(\n          mo => mo.name && mo.name.toLowerCase().indexOf(filterStr.toLowerCase()) > -1\n        );\n      })\n    );\n  }\n\n  ngOnDestroy() {\n    this.operationsSubscription.unsubscribe();\n    this.moOnUpdateSubscription.unsubscribe();\n    this.moOnDeleteSubscription.unsubscribe();\n  }\n\n  updateProfileItems(device, profile) {\n    this.firmwareItems = this.deviceProfileService.getFirmwareItems(device, profile);\n    this.softwareItems = this.deviceProfileService.getSoftwareItems(device, profile);\n    this.configurationItems = this.deviceProfileService.getConfigurationItems(device, profile);\n  }\n\n  private subscribeToManagedObjects() {\n    this.moOnUpdateSubscription = this.deviceRealtime\n      .onUpdate$(this.device.id)\n      .subscribe((managedObject: IManagedObject) => {\n        this.updateProfileItems(managedObject, this.selectedProfile);\n      });\n    this.moOnDeleteSubscription = this.deviceRealtime.onDelete$(this.device.id).subscribe(() => {\n      this.alertService.danger(\n        gettext(\n          'This device has just been deleted. You will be redirected to \"All devices\" page now.'\n        )\n      );\n      window.location.href = '#/device';\n    });\n  }\n\n  private subscribeToOperations() {\n    this.operationsSubscription = this.operationRealtime\n      .onAll$(this.device.id)\n      .pipe(\n        map(({ data }) => data as IOperation),\n        filter(operation => operation.c8y_DeviceProfile)\n      )\n      .subscribe(operation => {\n        this.operation = operation;\n      });\n  }\n\n  private toProfileForDevice(profile: DeviceProfile): DeviceProfile {\n    if (\n      Array.from(profile?.c8y_DeviceProfile?.software || []).length === 0 ||\n      has(this.device, 'c8y_SupportedSoftwareTypes')\n    ) {\n      return profile;\n    } else {\n      return {\n        ...profile,\n        c8y_DeviceProfile: {\n          ...profile.c8y_DeviceProfile,\n          software: profile.c8y_DeviceProfile.software.map(sw =>\n            pickBy(sw, (_, key) => key !== 'softwareType')\n          )\n        }\n      };\n    }\n  }\n}\n","<c8y-action-bar-item [placement]=\"'right'\">\n  <button\n    class=\"btn btn-link\"\n    title=\"{{ 'Reload' | translate }}\"\n    type=\"button\"\n    (click)=\"getDeviceProfilesAndUpdateProfileItems()\"\n  >\n    <i\n      c8yIcon=\"refresh\"\n      [ngClass]=\"{ 'icon-spin': reloading }\"\n    ></i>\n    {{ 'Reload' | translate }}\n  </button>\n</c8y-action-bar-item>\n<c8y-action-bar-item [placement]=\"'right'\">\n  <c8y-realtime-btn [service]=\"deviceRealtime\"></c8y-realtime-btn>\n</c8y-action-bar-item>\n\n<div class=\"card card--grid--fullpage card--grid--fullpage card--grid grid__row--2-10--md\">\n  <div class=\"card--grid grid__col--6-6--md\">\n    <!-- AVAILABLE PROFILES -->\n    <div class=\"bg-level-0\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Device profile\n        </div>\n      </div>\n      <div class=\"p-16\">\n        <form #deviceProfileForm=\"ngForm\">\n          <div class=\"input-group\">\n            <c8y-typeahead\n              class=\"flex-grow\"\n              placeholder=\"{{ 'Select device profile' | translate }}\"\n              name=\"selectProfile\"\n              data-cy=\"device-tab-profile--select-device-profile\"\n              [(ngModel)]=\"selectedProfile\"\n              (onSearch)=\"setPipe($event)\"\n              [allowFreeEntries]=\"false\"\n            >\n              <c8y-li\n                class=\"p-l-8 p-r-8 c8y-list__item--link\"\n                *c8yFor=\"let profile of deviceProfiles; pipe: filterPipe\"\n                (click)=\"selectProfile(profile); setPipe('')\"\n              >\n                <c8y-highlight\n                  [text]=\"profile.name || '&#45;&#45;'\"\n                  [pattern]=\"pattern\"\n                ></c8y-highlight>\n              </c8y-li>\n            </c8y-typeahead>\n            <div class=\"input-group-btn\">\n              <button\n                class=\"btn btn-primary\"\n                title=\"{{ 'Assign device profile' | translate }}\"\n                type=\"button\"\n                (click)=\"createOperation()\"\n                data-cy=\"device-tab-profile--Assign-device-profile-button\"\n                [disabled]=\"!selectedProfile?.id\"\n                c8yProductExperience\n                inherit\n                [actionData]=\"{ action: PRODUCT_EXPERIENCE.ACTIONS.ASSIGN_DEVICE_PROFILE }\"\n              >\n                <span>{{ 'Assign device profile' | translate }}</span>\n              </button>\n            </div>\n          </div>\n        </form>\n      </div>\n    </div>\n\n    <!-- INSTALL PROFILE OPERATION -->\n    <div class=\"bg-level-1\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Currently installed\n        </div>\n      </div>\n      <div class=\"card-block\">\n        <c8y-operation-details\n          [operation]=\"operation\"\n          c8yProductExperience\n          inherit\n          suppressDataOverriding\n        ></c8y-operation-details>\n      </div>\n    </div>\n  </div>\n  <div class=\"card--grid__inner-scroll d-col no-align-items\">\n    <div class=\"d-contents\">\n      <!-- FIRMWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-firmware'\"\n        [sectionTitle]=\"'Firmware' | translate\"\n        [emptyStateText]=\"'No firmware to display.' | translate\"\n        [emptyStateDetails]=\"'No firmware assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"firmwareItems\"\n        [isEmpty]=\"!selectedProfile?.c8y_DeviceProfile?.firmware?.name\"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- SOFTWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-tools'\"\n        [sectionTitle]=\"'Software' | translate\"\n        [emptyStateText]=\"'No software to display.' | translate\"\n        [emptyStateDetails]=\"'No software assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"softwareItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.software ||\n          selectedProfile?.c8y_DeviceProfile?.software?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- CONFIGURATION -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'gears'\"\n        [sectionTitle]=\"'Configuration' | translate\"\n        [emptyStateText]=\"'No configuration to display' | translate\"\n        [emptyStateDetails]=\"'No configuration assigned' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"configurationItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.configuration ||\n          selectedProfile?.c8y_DeviceProfile?.configuration?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <!-- fill in the remanining vertical space when empty -->\n    <div class=\"card--grid grid__col--6-6--md flex-grow\">\n      <div class=\"bg-level-0\"></div>\n      <div class=\"bg-level-1\"></div>\n    </div>\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device-tab-profile.component.js","sourceRoot":"","sources":["../../../../device-profile/device-tab-profile/device-tab-profile.component.ts","../../../../device-profile/device-tab-profile/device-tab-profile.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, DestroyRef, forwardRef, inject, OnInit } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ActivatedRoute } from '@angular/router';\nimport { IManagedObject, IOperation, IResultList } from '@c8y/client';\nimport {\n  AlertService,\n  ForOfFilterPipe,\n  gettext,\n  ManagedObjectRealtimeService,\n  OperationRealtimeService,\n  PRODUCT_EXPERIENCE_EVENT_SOURCE,\n  ProductExperienceEvent,\n  ProductExperienceEventSource\n} from '@c8y/ngx-components';\nimport { has, pickBy } from 'lodash-es';\nimport { BehaviorSubject, combineLatest, Observable, pipe } from 'rxjs';\nimport { filter, map, switchMap, tap } from 'rxjs/operators';\nimport {\n  ComparisonResult,\n  DeviceProfile,\n  PRODUCT_EXPERIENCE_DEVICE_PROFILE\n} from '../device-profile.model';\nimport { DeviceProfileService } from '../device-profile.service';\n\n@Component({\n  selector: 'c8y-device-tab-profile',\n  templateUrl: './device-tab-profile.component.html',\n  providers: [\n    ManagedObjectRealtimeService,\n    {\n      provide: PRODUCT_EXPERIENCE_EVENT_SOURCE,\n      useExisting: forwardRef(() => DeviceTabProfileComponent)\n    }\n  ]\n})\nexport class DeviceTabProfileComponent implements OnInit, ProductExperienceEventSource {\n  PRODUCT_EXPERIENCE = PRODUCT_EXPERIENCE_DEVICE_PROFILE;\n  device: IManagedObject;\n  deviceProfiles$: Observable<IResultList<IManagedObject>>;\n  selectedProfile: Partial<DeviceProfile>;\n  operation: IOperation;\n  firmwareItems: ComparisonResult[] = [];\n  softwareItems: ComparisonResult[] = [];\n  configurationItems: ComparisonResult[] = [];\n\n  filterPipe: ForOfFilterPipe;\n  pattern$ = new BehaviorSubject<string>('');\n  reload$ = new BehaviorSubject<boolean>(true);\n  productExperienceEvent: ProductExperienceEvent = {\n    eventName: PRODUCT_EXPERIENCE_DEVICE_PROFILE.EVENTS.DEVICE_TAB,\n    data: {\n      component: PRODUCT_EXPERIENCE_DEVICE_PROFILE.COMPONENTS.DEVICE_TAB_PROFILE\n    }\n  };\n  private destroyRef = inject(DestroyRef);\n\n  constructor(\n    public deviceRealtime: ManagedObjectRealtimeService,\n    private deviceProfileService: DeviceProfileService,\n    private route: ActivatedRoute,\n    private operationRealtime: OperationRealtimeService,\n    private alertService: AlertService\n  ) {\n    this.device = this.route.snapshot.parent.data.contextData;\n  }\n\n  async ngOnInit() {\n    this.getDeviceProfilesAndUpdateProfileItems();\n    this.subscribeToManagedObjects();\n    const supportedSoftwareTypes = new Set(this.device.c8y_SupportedSoftwareTypes);\n    const isSubset = (profileTypes: string[]) => {\n      return profileTypes.every(type => supportedSoftwareTypes.has(type));\n    };\n    this.filterPipe = pipe(\n      map(data => {\n        if (supportedSoftwareTypes.size) {\n          return data.filter(mo =>\n            isSubset(this.deviceProfileService.getSoftwareTypes(mo as unknown as DeviceProfile))\n          );\n        } else {\n          return data;\n        }\n      })\n    );\n  }\n\n  async getDeviceProfilesAndUpdateProfileItems() {\n    this.deviceProfiles$ = combineLatest([this.reload$.pipe(filter(Boolean)), this.pattern$]).pipe(\n      switchMap(([_, name]) =>\n        this.deviceProfileService.getDeviceProfilesByDevice(this.device, name)\n      ),\n      tap(async profiles => {\n        if (this.device.c8y_Profile) {\n          const profileId = this.device.c8y_Profile.profileId;\n          this.selectedProfile = profiles.data.find(mo => mo.id === profileId);\n        }\n        this.updateProfileItems(this.device, this.selectedProfile);\n        this.operation = await this.deviceProfileService.getProfileOperation(this.device.id);\n        this.subscribeToOperations();\n      }),\n      tap(() => this.reload$.next(false)),\n      takeUntilDestroyed(this.destroyRef)\n    );\n  }\n\n  selectProfile(mo: DeviceProfile) {\n    this.selectedProfile = this.toProfileForDevice(mo);\n    this.updateProfileItems(this.device, this.selectedProfile);\n  }\n\n  async createOperation() {\n    this.operation = await this.deviceProfileService.createProfileOperation(\n      this.device,\n      this.selectedProfile\n    );\n  }\n\n  updateProfileItems(device, profile) {\n    this.firmwareItems = this.deviceProfileService.getFirmwareItems(device, profile);\n    this.softwareItems = this.deviceProfileService.getSoftwareItems(device, profile);\n    this.configurationItems = this.deviceProfileService.getConfigurationItems(device, profile);\n  }\n\n  private subscribeToManagedObjects() {\n    this.deviceRealtime\n      .onUpdate$(this.device.id)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((managedObject: IManagedObject) => {\n        this.updateProfileItems(managedObject, this.selectedProfile);\n      });\n    this.deviceRealtime\n      .onDelete$(this.device.id)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(() => {\n        this.alertService.danger(\n          gettext(\n            'This device has just been deleted. You will be redirected to \"All devices\" page now.'\n          )\n        );\n        window.location.href = '#/device';\n      });\n  }\n\n  private subscribeToOperations() {\n    this.operationRealtime\n      .onAll$(this.device.id)\n      .pipe(\n        map(({ data }) => data as IOperation),\n        filter(operation => operation.c8y_DeviceProfile),\n        takeUntilDestroyed(this.destroyRef)\n      )\n      .subscribe(operation => {\n        this.operation = operation;\n      });\n  }\n\n  private toProfileForDevice(profile: DeviceProfile): DeviceProfile {\n    if (\n      Array.from(profile?.c8y_DeviceProfile?.software || []).length === 0 ||\n      has(this.device, 'c8y_SupportedSoftwareTypes')\n    ) {\n      return profile;\n    } else {\n      return {\n        ...profile,\n        c8y_DeviceProfile: {\n          ...profile.c8y_DeviceProfile,\n          software: profile.c8y_DeviceProfile.software.map(sw =>\n            pickBy(sw, (_, key) => key !== 'softwareType')\n          )\n        }\n      };\n    }\n  }\n}\n","<c8y-action-bar-item [placement]=\"'right'\">\n  <button\n    class=\"btn btn-link\"\n    title=\"{{ 'Reload' | translate }}\"\n    type=\"button\"\n    (click)=\"reload$.next(true)\"\n  >\n    <i\n      c8yIcon=\"refresh\"\n      [ngClass]=\"{ 'icon-spin': reload$.value }\"\n    ></i>\n    {{ 'Reload' | translate }}\n  </button>\n</c8y-action-bar-item>\n<c8y-action-bar-item [placement]=\"'right'\">\n  <c8y-realtime-btn [service]=\"deviceRealtime\"></c8y-realtime-btn>\n</c8y-action-bar-item>\n\n<div class=\"card card--grid--fullpage card--grid--fullpage card--grid grid__row--2-10--md\">\n  <div class=\"card--grid grid__col--6-6--md\">\n    <!-- AVAILABLE PROFILES -->\n    <div class=\"bg-level-0\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Device profile\n        </div>\n      </div>\n      <div class=\"p-16\">\n        <form #deviceProfileForm=\"ngForm\">\n          <div class=\"input-group\">\n            <c8y-typeahead\n              class=\"flex-grow\"\n              placeholder=\"{{ 'Select device profile' | translate }}\"\n              name=\"selectProfile\"\n              data-cy=\"device-tab-profile--select-device-profile\"\n              [(ngModel)]=\"selectedProfile\"\n              (onSearch)=\"pattern$.next($event)\"\n              [allowFreeEntries]=\"false\"\n            >\n              <c8y-li\n                class=\"p-l-8 p-r-8 c8y-list__item--link\"\n                *c8yFor=\"let profile of deviceProfiles$; pipe: filterPipe\"\n                (click)=\"selectProfile(profile); pattern$.next('')\"\n              >\n                <c8y-highlight\n                  [text]=\"profile.name || '&#45;&#45;'\"\n                  [pattern]=\"pattern$.value\"\n                ></c8y-highlight>\n              </c8y-li>\n            </c8y-typeahead>\n            <div class=\"input-group-btn\">\n              <button\n                class=\"btn btn-primary\"\n                title=\"{{ 'Assign device profile' | translate }}\"\n                type=\"button\"\n                (click)=\"createOperation()\"\n                data-cy=\"device-tab-profile--Assign-device-profile-button\"\n                [disabled]=\"!selectedProfile?.id\"\n                c8yProductExperience\n                inherit\n                [actionData]=\"{ action: PRODUCT_EXPERIENCE.ACTIONS.ASSIGN_DEVICE_PROFILE }\"\n              >\n                <span>{{ 'Assign device profile' | translate }}</span>\n              </button>\n            </div>\n          </div>\n        </form>\n      </div>\n    </div>\n\n    <!-- INSTALL PROFILE OPERATION -->\n    <div class=\"bg-level-1\">\n      <div class=\"card-header separator\">\n        <div\n          class=\"card-title\"\n          translate\n        >\n          Currently installed\n        </div>\n      </div>\n      <div class=\"card-block\">\n        <c8y-operation-details\n          [operation]=\"operation\"\n          c8yProductExperience\n          inherit\n          suppressDataOverriding\n        ></c8y-operation-details>\n      </div>\n    </div>\n  </div>\n  <div class=\"card--grid__inner-scroll d-col no-align-items\">\n    <div class=\"d-contents\">\n      <!-- FIRMWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-firmware'\"\n        [sectionTitle]=\"'Firmware' | translate\"\n        [emptyStateText]=\"'No firmware to display.' | translate\"\n        [emptyStateDetails]=\"'No firmware assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"firmwareItems\"\n        [isEmpty]=\"!selectedProfile?.c8y_DeviceProfile?.firmware?.name\"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- SOFTWARE -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'c8y-tools'\"\n        [sectionTitle]=\"'Software' | translate\"\n        [emptyStateText]=\"'No software to display.' | translate\"\n        [emptyStateDetails]=\"'No software assigned.' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"softwareItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.software ||\n          selectedProfile?.c8y_DeviceProfile?.software?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <div class=\"d-contents\">\n      <!-- CONFIGURATION -->\n      <c8y-device-tab-profile-detail\n        class=\"d-contents\"\n        [sectionIcon]=\"'gears'\"\n        [sectionTitle]=\"'Configuration' | translate\"\n        [emptyStateText]=\"'No configuration to display' | translate\"\n        [emptyStateDetails]=\"'No configuration assigned' | translate\"\n        [isProfileSelected]=\"!!selectedProfile\"\n        [items]=\"configurationItems\"\n        [isEmpty]=\"\n          !selectedProfile?.c8y_DeviceProfile?.configuration ||\n          selectedProfile?.c8y_DeviceProfile?.configuration?.length === 0\n        \"\n      ></c8y-device-tab-profile-detail>\n    </div>\n    <!-- fill in the remanining vertical space when empty -->\n    <div class=\"card--grid grid__col--6-6--md flex-grow\">\n      <div class=\"bg-level-0\"></div>\n      <div class=\"bg-level-1\"></div>\n    </div>\n  </div>\n</div>\n"]}