add related items logic

application/src/main/java/org/thingsboard/server/controller/IotHubController.java

@@ -46,6 +46,8 @@ import org.thingsboard.server.dao.iot_hub.IotHubInstalledItemService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.security.system.SystemSecurityService;
 import org.thingsboard.server.service.iot_hub.InstallItemVersionResult;
+import org.thingsboard.server.service.iot_hub.InstallPlan;
+import org.thingsboard.server.service.iot_hub.InstallPlanResult;
 import org.thingsboard.server.service.iot_hub.UpdateItemVersionResult;
 import org.thingsboard.server.service.iot_hub.IotHubService;
 
@@ -71,6 +73,23 @@ public class IotHubController extends BaseController {
         return iotHubService.installItemVersion(getCurrentUser(), versionId, data, request);
     }
 
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @GetMapping("/versions/{versionId}/installPlan")
+    @ResponseBody
+    public InstallPlan resolveInstallPlan(@PathVariable String versionId) throws ThingsboardException {
+        return iotHubService.resolveInstallPlan(getCurrentUser(), versionId);
+    }
+
+    @PreAuthorize("hasAuthority('TENANT_ADMIN')")
+    @PostMapping("/installPlan")
+    @ResponseBody
+    public InstallPlanResult installPlan(@RequestBody InstallPlanRequest body,
+                                         HttpServletRequest request) throws ThingsboardException {
+        return iotHubService.installPlan(getCurrentUser(), body.plan(), body.data(), request);
+    }
+
+    public record InstallPlanRequest(InstallPlan plan, JsonNode data) {}
+
     @PreAuthorize("hasAuthority('TENANT_ADMIN')")
     @PostMapping("/device/register")
     @ResponseBody

application/src/main/java/org/thingsboard/server/service/iot_hub/DefaultIotHubService.java

@@ -71,8 +71,11 @@ import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.HexFormat;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Set;
 import java.util.UUID;
 
 @Service
@@ -103,48 +106,61 @@ public class DefaultIotHubService implements IotHubService {
     public InstallItemVersionResult installItemVersion(SecurityUser user, String versionId, JsonNode data, HttpServletRequest request) {
         TenantId tenantId = user.getTenantId();
         log.info("[{}] Installing IoT Hub item version: {}", tenantId, versionId);
-
         try {
-            JsonNode versionInfo = iotHubRestClient.getVersionInfo(versionId);
-            String itemType = versionInfo.get("type").asText();
-            String itemName = versionInfo.get("name").asText();
-            UUID itemId = UUID.fromString(versionInfo.get("itemId").asText());
-            String version = versionInfo.get("version").asText();
-            log.debug("[{}] Fetched version info: {} (type: {})", tenantId, itemName, itemType);
-
-            byte[] fileData = iotHubRestClient.getVersionFileData(versionId);
-            log.debug("[{}] Fetched file data, size: {} bytes", tenantId, fileData != null ? fileData.length : 0);
-
-            IotHubInstalledItemDescriptor descriptor = switch (itemType) {
-                case "WIDGET" -> installWidget(user, tenantId, fileData);
-                case "DASHBOARD" -> installDashboard(user, tenantId, fileData);
-                case "CALCULATED_FIELD" -> installCalculatedField(user, tenantId, fileData, data);
-                case "ALARM_RULE" -> throw new IllegalArgumentException(
-                        "Alarm Rules require ThingsBoard 4.3 or later. Please update your platform instance to install Alarm Rule packages.");
-                case "RULE_CHAIN" -> installRuleChain(user, tenantId, fileData, data);
-                case "DEVICE" -> installDeviceProfile(user, tenantId, fileData);
-                case "SOLUTION_TEMPLATE" -> installSolution(user, tenantId, fileData, request);
-                default -> throw new IllegalArgumentException("Unsupported IoT Hub item type: " + itemType);
-            };
+            IotHubInstalledItem installedItem = doInstallVersion(user, versionId, data, request);
+            return InstallItemVersionResult.success(installedItem.getDescriptor());
+        } catch (Exception e) {
+            log.error("[{}] Failed to install IoT Hub item version: {}", tenantId, versionId, e);
+            return InstallItemVersionResult.error(e.getMessage());
+        }
+    }
 
-            IotHubInstalledItem installedItem = new IotHubInstalledItem();
-            installedItem.setTenantId(tenantId);
-            installedItem.setItemId(itemId);
-            installedItem.setItemVersionId(UUID.fromString(versionId));
-            installedItem.setItemName(itemName);
-            installedItem.setItemType(itemType);
-            installedItem.setVersion(version);
-            installedItem.setDescriptor(descriptor);
-            iotHubInstalledItemService.save(tenantId, installedItem);
+    /**
+     * Fetch + apply a single marketplace version, persist the installed-item record, and ping
+     * the marketplace install counter. Throws on failure so callers (cascade install) can roll back.
+     */
+    private IotHubInstalledItem doInstallVersion(SecurityUser user, String versionId, JsonNode data, HttpServletRequest request) throws Exception {
+        TenantId tenantId = user.getTenantId();
+        JsonNode versionInfo = iotHubRestClient.getVersionInfo(versionId);
+        String itemType = versionInfo.get("type").asText();
+        String itemName = versionInfo.get("name").asText();
+        UUID itemId = UUID.fromString(versionInfo.get("itemId").asText());
+        String version = versionInfo.get("version").asText();
+        log.debug("[{}] Fetched version info: {} (type: {})", tenantId, itemName, itemType);
+
+        byte[] fileData = iotHubRestClient.getVersionFileData(versionId);
+        log.debug("[{}] Fetched file data, size: {} bytes", tenantId, fileData != null ? fileData.length : 0);
+
+        IotHubInstalledItemDescriptor descriptor = switch (itemType) {
+            case "WIDGET" -> installWidget(user, tenantId, fileData);
+            case "DASHBOARD" -> installDashboard(user, tenantId, fileData);
+            case "CALCULATED_FIELD" -> installCalculatedField(user, tenantId, fileData, data);
+            case "ALARM_RULE" -> throw new IllegalArgumentException(
+                    "Alarm Rules require ThingsBoard 4.3 or later. Please update your platform instance to install Alarm Rule packages.");
+            case "RULE_CHAIN" -> installRuleChain(user, tenantId, fileData, data);
+            case "DEVICE" -> installDeviceProfile(user, tenantId, fileData);
+            case "SOLUTION_TEMPLATE" -> installSolution(user, tenantId, fileData, request);
+            default -> throw new IllegalArgumentException("Unsupported IoT Hub item type: " + itemType);
+        };
+
+        IotHubInstalledItem installedItem = new IotHubInstalledItem();
+        installedItem.setTenantId(tenantId);
+        installedItem.setItemId(itemId);
+        installedItem.setItemVersionId(UUID.fromString(versionId));
+        installedItem.setItemName(itemName);
+        installedItem.setItemType(itemType);
+        installedItem.setVersion(version);
+        installedItem.setDescriptor(descriptor);
+        installedItem = iotHubInstalledItemService.save(tenantId, installedItem);
 
+        try {
             iotHubRestClient.reportVersionInstalled(versionId);
-            log.info("[{}] Successfully installed IoT Hub item version: {} (type: {})", tenantId, itemName, itemType);
-
-            return InstallItemVersionResult.success(descriptor);
         } catch (Exception e) {
-            log.error("[{}] Failed to install IoT Hub item version: {}", tenantId, versionId, e);
-            return InstallItemVersionResult.error(e.getMessage());
+            // Counter ping is best-effort — do not fail the install if it errors.
+            log.warn("[{}] Failed to report install counter for version {}: {}", tenantId, versionId, e.getMessage());
         }
+        log.info("[{}] Successfully installed IoT Hub item version: {} (type: {})", tenantId, itemName, itemType);
+        return installedItem;
     }
 
     private WidgetInstalledItemDescriptor installWidget(SecurityUser user, TenantId tenantId, byte[] fileData) throws Exception {
@@ -654,4 +670,170 @@ public class DefaultIotHubService implements IotHubService {
         iotHubInstalledItemService.deleteById(tenantId, installedItemId);
         log.info("[{}] Deleted installed IoT Hub item: {}", tenantId, installedItem.getItemName());
     }
+
+    @Override
+    public InstallPlan resolveInstallPlan(SecurityUser user, String versionId) {
+        TenantId tenantId = user.getTenantId();
+        log.debug("[{}] Resolving install plan for version: {}", tenantId, versionId);
+
+        JsonNode rootVersion = iotHubRestClient.getVersionInfo(versionId);
+        if (rootVersion == null) {
+            throw new IllegalArgumentException("Marketplace version not found: " + versionId);
+        }
+
+        Set<UUID> alreadyInstalledItemIds = new HashSet<>(iotHubInstalledItemService.findInstalledItemIdsByTenantId(tenantId));
+
+        // LinkedHashMap preserves insertion order; we add deps before the root so a single
+        // forward iteration yields the correct topological install sequence.
+        LinkedHashMap<String, InstallPlanEntry> entries = new LinkedHashMap<>();
+        Set<String> visiting = new HashSet<>();
+
+        collectDependencies(rootVersion, alreadyInstalledItemIds, entries, visiting, true);
+
+        return new InstallPlan(versionId, new ArrayList<>(entries.values()));
+    }
+
+    /**
+     * Depth-first walk over {@code relatedItems}. Children are added BEFORE the current
+     * version so the resulting LinkedHashMap iterates deps-first, root-last.
+     */
+    private void collectDependencies(JsonNode versionInfo,
+                                     Set<UUID> alreadyInstalledItemIds,
+                                     LinkedHashMap<String, InstallPlanEntry> entries,
+                                     Set<String> visiting,
+                                     boolean root) {
+        String itemId = versionInfo.get("itemId").asText();
+        if (entries.containsKey(itemId)) {
+            return;
+        }
+        if (!visiting.add(itemId)) {
+            log.warn("Dependency cycle detected involving IoT Hub item {} — breaking", itemId);
+            return;
+        }
+
+        JsonNode related = versionInfo.get("relatedItems");
+        if (related != null && related.isArray()) {
+            for (JsonNode relatedNode : related) {
+                String relatedItemId = relatedNode.asText();
+                if (relatedItemId == null || relatedItemId.isEmpty() || entries.containsKey(relatedItemId)) {
+                    continue;
+                }
+                JsonNode relatedVersion;
+                try {
+                    relatedVersion = iotHubRestClient.getPublishedVersionByItemId(relatedItemId);
+                } catch (Exception e) {
+                    log.warn("Failed to fetch related item {}: {}", relatedItemId, e.getMessage());
+                    entries.put(relatedItemId, missingEntry(relatedItemId, e.getMessage()));
+                    continue;
+                }
+                if (relatedVersion == null) {
+                    log.warn("Related IoT Hub item {} is missing or unpublished — recording in plan", relatedItemId);
+                    entries.put(relatedItemId, missingEntry(relatedItemId, "Item not found or not published"));
+                    continue;
+                }
+                collectDependencies(relatedVersion, alreadyInstalledItemIds, entries, visiting, false);
+            }
+        }
+
+        visiting.remove(itemId);
+
+        InstallPlanEntry entry = new InstallPlanEntry();
+        entry.setItemId(itemId);
+        entry.setVersionId(versionInfo.get("id").asText());
+        entry.setName(versionInfo.hasNonNull("name") ? versionInfo.get("name").asText() : null);
+        entry.setType(versionInfo.hasNonNull("type") ? versionInfo.get("type").asText() : null);
+        entry.setVersion(versionInfo.hasNonNull("version") ? versionInfo.get("version").asText() : null);
+        entry.setRoot(root);
+        boolean alreadyInstalled;
+        try {
+            alreadyInstalled = alreadyInstalledItemIds.contains(UUID.fromString(itemId));
+        } catch (IllegalArgumentException ex) {
+            alreadyInstalled = false;
+        }
+        entry.setStatus(alreadyInstalled
+                ? InstallPlanEntry.Status.ALREADY_INSTALLED
+                : InstallPlanEntry.Status.WILL_INSTALL);
+        entries.put(itemId, entry);
+    }
+
+    private static InstallPlanEntry missingEntry(String itemId, String errorMessage) {
+        InstallPlanEntry entry = new InstallPlanEntry();
+        entry.setItemId(itemId);
+        entry.setStatus(InstallPlanEntry.Status.MISSING);
+        entry.setErrorMessage(errorMessage);
+        return entry;
+    }
+
+    @Override
+    public InstallPlanResult installPlan(SecurityUser user, InstallPlan plan, JsonNode data, HttpServletRequest request) {
+        TenantId tenantId = user.getTenantId();
+        if (plan == null || plan.getEntries() == null || plan.getEntries().isEmpty()) {
+            return new InstallPlanResult(false, false, "Install plan is empty", null, new ArrayList<>(), new ArrayList<>());
+        }
+
+        InstallPlanResult result = new InstallPlanResult();
+        List<InstallPlanEntry> resultEntries = new ArrayList<>();
+        List<String> missingItemIds = new ArrayList<>();
+        List<IotHubInstalledItemId> rollbackIds = new ArrayList<>();
+        IotHubInstalledItemDescriptor rootDescriptor = null;
+
+        for (InstallPlanEntry entry : plan.getEntries()) {
+            InstallPlanEntry resultEntry = cloneEntry(entry);
+            switch (entry.getStatus()) {
+                case MISSING -> {
+                    missingItemIds.add(entry.getItemId());
+                    resultEntries.add(resultEntry);
+                }
+                case ALREADY_INSTALLED -> resultEntries.add(resultEntry);
+                case WILL_INSTALL -> {
+                    try {
+                        // Only the root entry receives the user's install data (target profile entityId);
+                        // transitive deps install with defaults.
+                        JsonNode entryData = entry.isRoot() ? data : null;
+                        IotHubInstalledItem installed = doInstallVersion(user, entry.getVersionId(), entryData, request);
+                        rollbackIds.add(installed.getId());
+                        if (entry.isRoot()) {
+                            rootDescriptor = installed.getDescriptor();
+                        }
+                        resultEntries.add(resultEntry);
+                    } catch (Exception e) {
+                        log.error("[{}] Cascade install failed at entry {} ({}): {}", tenantId,
+                                entry.getName(), entry.getVersionId(), e.getMessage(), e);
+                        resultEntry.setErrorMessage(e.getMessage());
+                        resultEntries.add(resultEntry);
+                        rollbackInstalledItems(user, rollbackIds);
+                        result.setSuccess(false);
+                        result.setRolledBack(true);
+                        result.setErrorMessage("Failed to install '" + entry.getName() + "': " + e.getMessage());
+                        result.setEntries(resultEntries);
+                        result.setMissingItemIds(missingItemIds);
+                        return result;
+                    }
+                }
+            }
+        }
+
+        result.setSuccess(true);
+        result.setRolledBack(false);
+        result.setRootDescriptor(rootDescriptor);
+        result.setEntries(resultEntries);
+        result.setMissingItemIds(missingItemIds);
+        return result;
+    }
+
+    private void rollbackInstalledItems(SecurityUser user, List<IotHubInstalledItemId> installedIds) {
+        for (int i = installedIds.size() - 1; i >= 0; i--) {
+            IotHubInstalledItemId id = installedIds.get(i);
+            try {
+                deleteInstalledItem(user, id);
+            } catch (Exception e) {
+                log.error("[{}] Failed to roll back installed item {}: {}", user.getTenantId(), id, e.getMessage(), e);
+            }
+        }
+    }
+
+    private static InstallPlanEntry cloneEntry(InstallPlanEntry src) {
+        return new InstallPlanEntry(src.getItemId(), src.getVersionId(), src.getName(), src.getType(),
+                src.getVersion(), src.getStatus(), src.isRoot(), src.getErrorMessage());
+    }
 }

application/src/main/java/org/thingsboard/server/service/iot_hub/InstallPlan.java

@@ -0,0 +1,32 @@
+/**
+ * Copyright © 2016-2026 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.iot_hub;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class InstallPlan {
+
+    private String rootVersionId;
+    private List<InstallPlanEntry> entries;
+
+}

application/src/main/java/org/thingsboard/server/service/iot_hub/InstallPlanEntry.java

@@ -0,0 +1,42 @@
+/**
+ * Copyright © 2016-2026 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.iot_hub;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class InstallPlanEntry {
+
+    public enum Status {
+        WILL_INSTALL,
+        ALREADY_INSTALLED,
+        MISSING
+    }
+
+    private String itemId;
+    private String versionId;
+    private String name;
+    private String type;
+    private String version;
+    private Status status;
+    private boolean root;
+    private String errorMessage;
+
+}

application/src/main/java/org/thingsboard/server/service/iot_hub/InstallPlanResult.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright © 2016-2026 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.iot_hub;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.thingsboard.server.common.data.iot_hub.IotHubInstalledItemDescriptor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class InstallPlanResult {
+
+    private boolean success;
+    private boolean rolledBack;
+    private String errorMessage;
+    private IotHubInstalledItemDescriptor rootDescriptor;
+    private List<InstallPlanEntry> entries = new ArrayList<>();
+    private List<String> missingItemIds = new ArrayList<>();
+
+}

application/src/main/java/org/thingsboard/server/service/iot_hub/IotHubRestClient.java

@@ -18,8 +18,10 @@ package org.thingsboard.server.service.iot_hub;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Component;
+import org.springframework.web.client.HttpClientErrorException;
 import org.springframework.web.client.RestTemplate;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 
@@ -39,6 +41,23 @@ public class IotHubRestClient {
         return restTemplate.getForObject(url, JsonNode.class);
     }
 
+    /**
+     * Returns the latest published version of an item, or {@code null} if the marketplace
+     * responds with 404 (item missing or never published). Other 4xx/5xx still propagate.
+     */
+    public JsonNode getPublishedVersionByItemId(String itemId) {
+        String url = baseUrl + "/api/items/" + itemId + "/published";
+        log.debug("Fetching IoT Hub published version for item: {}", url);
+        try {
+            return restTemplate.getForObject(url, JsonNode.class);
+        } catch (HttpClientErrorException e) {
+            if (e.getStatusCode() == HttpStatus.NOT_FOUND) {
+                return null;
+            }
+            throw e;
+        }
+    }
+
     public byte[] getVersionFileData(String versionId) {
         String url = baseUrl + "/api/versions/" + versionId + "/fileData";
         log.debug("Fetching IoT Hub version file data: {}", url);

application/src/main/java/org/thingsboard/server/service/iot_hub/IotHubService.java

@@ -30,4 +30,8 @@ public interface IotHubService {
     InstallItemVersionResult registerDeviceInstall(SecurityUser user, String versionId, DeviceInstalledItemDescriptor descriptor);
 
     void deleteInstalledItem(SecurityUser user, IotHubInstalledItemId installedItemId);
+
+    InstallPlan resolveInstallPlan(SecurityUser user, String versionId);
+
+    InstallPlanResult installPlan(SecurityUser user, InstallPlan plan, JsonNode data, HttpServletRequest request);
 }

ui-ngx/src/app/core/http/iot-hub-api.service.ts

@@ -22,7 +22,7 @@ import { PageData } from '@shared/models/page/page-data';
 import { PageLink } from '@shared/models/page/page-link';
 import { MpItemVersionQuery, MpItemVersionView } from '@shared/models/iot-hub/iot-hub-version.models';
 import { CreatorView } from '@shared/models/iot-hub/iot-hub-creator.models';
-import { IotHubInstalledItem, InstallItemVersionResult, UpdateItemVersionResult, ItemPublishedVersionInfo } from '@shared/models/iot-hub/iot-hub-installed-item.models';
+import { IotHubInstalledItem, InstallItemVersionResult, InstallPlan, InstallPlanResult, UpdateItemVersionResult, ItemPublishedVersionInfo } from '@shared/models/iot-hub/iot-hub-installed-item.models';
 import { ItemType, ItemTypeFilterInfo, WidgetCategory } from '@shared/models/iot-hub/iot-hub-item.models';
 import { InterceptorHttpParams } from '@core/interceptors/interceptor-http-params';
 import { InterceptorConfig } from '@core/interceptors/interceptor-config';
@@ -162,6 +162,21 @@ export class IotHubApiService {
     );
   }
 
+  public resolveInstallPlan(versionId: string, config?: IotHubRequestConfig): Observable<InstallPlan> {
+    return this.http.get<InstallPlan>(
+      `/api/iot-hub/versions/${versionId}/installPlan`,
+      { params: this.buildParams(config) }
+    );
+  }
+
+  public installPlan(plan: InstallPlan, data?: any, config?: IotHubRequestConfig): Observable<InstallPlanResult> {
+    return this.http.post<InstallPlanResult>(
+      `/api/iot-hub/installPlan`,
+      { plan, data: data ?? null },
+      { params: this.buildParams(config) }
+    );
+  }
+
   public updateItemVersion(installedItemId: string, versionId: string, config?: IotHubRequestConfig, force?: boolean): Observable<UpdateItemVersionResult> {
     let params = this.buildParams(config);
     if (force) {

ui-ngx/src/app/modules/home/components/iot-hub/iot-hub-install-dialog.component.html

@@ -48,6 +48,45 @@
             existing: pendingOverwrite?.existingRuleChainName
          }"></p>
     }
+    @case ('plan') {
+      <h2 class="tb-iot-hub-install-title">{{ 'iot-hub.install-plan-title' | translate:{ name: item.name } }}</h2>
+      <p class="tb-iot-hub-install-desc">
+        @if (planSummary.willInstall > 0) {
+          <span>{{ 'iot-hub.install-plan-will-install' | translate:{ count: planSummary.willInstall } }}</span>
+        }
+        @if (planSummary.alreadyInstalled > 0) {
+          <span>{{ 'iot-hub.install-plan-will-update' | translate:{ count: planSummary.alreadyInstalled } }}</span>
+        }
+      </p>
+      @if (planSummary.missing > 0) {
+        <p class="tb-iot-hub-install-warning">{{ 'iot-hub.install-plan-missing-warning' | translate:{ count: planSummary.missing } }}</p>
+      }
+      <ul class="tb-iot-hub-plan-list">
+        @for (entry of installPlan?.entries; track entry.itemId) {
+          <li class="tb-iot-hub-plan-entry">
+            <div class="tb-iot-hub-plan-entry-main">
+              <span class="tb-iot-hub-plan-entry-name">{{ entry.name || entry.itemId }}</span>
+              @if (entry.type) {
+                <span class="tb-iot-hub-plan-entry-type">{{ (typeTranslations.get(entry.type) || entry.type) | translate }}</span>
+              }
+              @if (entry.version) {
+                <span class="tb-iot-hub-plan-entry-version">v{{ entry.version }}</span>
+              }
+            </div>
+            <span class="tb-iot-hub-plan-entry-status"
+                  [class.tb-status-installed]="entry.status === PlanStatus.ALREADY_INSTALLED"
+                  [class.tb-status-missing]="entry.status === PlanStatus.MISSING"
+                  [class.tb-status-will-install]="entry.status === PlanStatus.WILL_INSTALL">
+              @switch (entry.status) {
+                @case (PlanStatus.WILL_INSTALL) { {{ 'iot-hub.install-plan-status-will' | translate }} }
+                @case (PlanStatus.ALREADY_INSTALLED) { {{ 'iot-hub.install-plan-status-installed' | translate }} }
+                @case (PlanStatus.MISSING) { {{ 'iot-hub.install-plan-status-missing' | translate }} }
+              }
+            </span>
+          </li>
+        }
+      </ul>
+    }
     @case ('installing') {
       <h2 class="tb-iot-hub-install-title">{{ 'iot-hub.install-confirm-title' | translate:{ name: item.name } }}</h2>
       <p class="tb-iot-hub-install-desc">{{ 'iot-hub.install-desc' | translate }}</p>
@@ -56,6 +95,20 @@
       <h2 class="tb-iot-hub-install-title">{{ 'iot-hub.install-success-title' | translate }}</h2>
       <p class="tb-iot-hub-install-desc">{{ 'iot-hub.install-success-desc' | translate:{ name: item.name } }}</p>
     }
+    @case ('partial') {
+      <h2 class="tb-iot-hub-install-title">{{ 'iot-hub.install-partial-title' | translate }}</h2>
+      <p class="tb-iot-hub-install-desc">{{ 'iot-hub.install-partial-desc' | translate:{ name: item.name } }}</p>
+      <ul class="tb-iot-hub-plan-list">
+        @for (entry of missingEntries; track entry.itemId) {
+          <li class="tb-iot-hub-plan-entry">
+            <span class="tb-iot-hub-plan-entry-name">{{ entry.name || entry.itemId }}</span>
+            @if (entry.errorMessage) {
+              <span class="tb-iot-hub-plan-entry-error">{{ entry.errorMessage }}</span>
+            }
+          </li>
+        }
+      </ul>
+    }
     @case ('error') {
       <h2 class="tb-iot-hub-install-title">{{ 'iot-hub.install-error-title' | translate }}</h2>
       <p class="tb-iot-hub-install-desc">{{ 'iot-hub.install-error-message' | translate:{ name: item.name } }}</p>
@@ -72,39 +125,66 @@
 <mat-dialog-actions align="end">
   @switch (state) {
     @case ('confirm') {
-      <button mat-button (click)="cancel()">{{ 'action.cancel' | translate }}</button>
+      <button mat-button [disabled]="resolvingPlan" (click)="cancel()">{{ 'action.cancel' | translate }}</button>
       @if (item.type === ItemType.RULE_CHAIN) {
-        <button mat-stroked-button (click)="install()">{{ 'iot-hub.install' | translate }}</button>
-        <button mat-flat-button color="primary" (click)="installAsEntityProfileDefault()">
+        <button mat-stroked-button [disabled]="resolvingPlan" (click)="install()">
+          @if (resolvingPlan) {
+            <mat-spinner diameter="18" class="mr-2 inline-block align-middle"></mat-spinner>
+          }
+          {{ 'iot-hub.install' | translate }}
+        </button>
+        <button mat-flat-button color="primary" [disabled]="resolvingPlan" (click)="installAsEntityProfileDefault()">
           {{ 'iot-hub.rule-chain-install-as-default' | translate }}
         </button>
       } @else {
-        <button mat-flat-button color="primary" (click)="install()">{{ 'iot-hub.install' | translate }}</button>
+        <button mat-flat-button color="primary" [disabled]="resolvingPlan" (click)="install()">
+          @if (resolvingPlan) {
+            <mat-spinner diameter="18" class="mr-2 inline-block align-middle"></mat-spinner>
+          }
+          {{ 'iot-hub.install' | translate }}
+        </button>
       }
     }
     @case ('select-entity') {
-      <button mat-button (click)="cancel()">{{ 'action.cancel' | translate }}</button>
+      <button mat-button [disabled]="resolvingPlan" (click)="cancel()">{{ 'action.cancel' | translate }}</button>
       @if (item.type === ItemType.RULE_CHAIN) {
-        <button mat-button (click)="selectEntityBack()">{{ 'action.back' | translate }}</button>
+        <button mat-button [disabled]="resolvingPlan" (click)="selectEntityBack()">{{ 'action.back' | translate }}</button>
         <button mat-flat-button color="primary"
-                [disabled]="!selectedEntityId"
+                [disabled]="!selectedEntityId || resolvingPlan"
                 (click)="onSelectEntityInstall()">
+          @if (resolvingPlan) {
+            <mat-spinner diameter="18" class="mr-2 inline-block align-middle"></mat-spinner>
+          }
           {{ 'iot-hub.install' | translate }}
         </button>
       } @else {
         <button mat-flat-button color="primary"
-                [disabled]="activeSelectEntityConfig?.required && !selectedEntityId"
+                [disabled]="(activeSelectEntityConfig?.required && !selectedEntityId) || resolvingPlan"
                 (click)="onSelectEntityInstall()">
+          @if (resolvingPlan) {
+            <mat-spinner diameter="18" class="mr-2 inline-block align-middle"></mat-spinner>
+          }
           {{ 'iot-hub.install' | translate }}
         </button>
       }
     }
     @case ('confirm-overwrite') {
-      <button mat-button (click)="confirmOverwriteCancel()">{{ 'action.cancel' | translate }}</button>
-      <button mat-flat-button color="primary" (click)="confirmOverwriteReplace()">
+      <button mat-button [disabled]="resolvingPlan" (click)="confirmOverwriteCancel()">{{ 'action.cancel' | translate }}</button>
+      <button mat-flat-button color="primary" [disabled]="resolvingPlan" (click)="confirmOverwriteReplace()">
+        @if (resolvingPlan) {
+          <mat-spinner diameter="18" class="mr-2 inline-block align-middle"></mat-spinner>
+        }
         {{ 'iot-hub.rule-chain-overwrite-replace' | translate }}
       </button>
     }
+    @case ('plan') {
+      <button mat-button (click)="cancelPlan()">{{ 'action.cancel' | translate }}</button>
+      <button mat-flat-button color="primary"
+              [disabled]="planSummary.willInstall === 0"
+              (click)="confirmPlan()">
+        {{ 'iot-hub.install-plan-confirm' | translate }}
+      </button>
+    }
     @case ('installing') {
       <button mat-button disabled>{{ 'action.cancel' | translate }}</button>
       <button mat-flat-button color="primary" disabled>
@@ -120,6 +200,14 @@
         </button>
       }
     }
+    @case ('partial') {
+      <button mat-button (click)="close()">{{ (entityDetailsUrl ? 'action.cancel' : 'action.close') | translate }}</button>
+      @if (entityDetailsUrl) {
+        <button mat-flat-button color="primary" (click)="openEntityDetails()">
+          {{ 'iot-hub.open-item-type' | translate:{ type: getTypeLabel() } }}
+        </button>
+      }
+    }
     @case ('error') {
       <button mat-button (click)="close()">{{ 'action.close' | translate }}</button>
     }

ui-ngx/src/app/modules/home/components/iot-hub/iot-hub-install-dialog.component.scss

@@ -57,3 +57,92 @@ tb-entity-select {
   border-radius: 8px;
   padding-bottom: 24px;
 }
+
+.tb-iot-hub-install-warning {
+  color: #b26a00;
+  background: #fff8e1;
+  border-left: 3px solid #f5b324;
+  padding: 8px 12px;
+  font-size: 13px;
+  line-height: 18px;
+  border-radius: 4px;
+  margin: 0;
+}
+
+.tb-iot-hub-plan-list {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+  border: 1px solid rgba(0, 0, 0, 0.12);
+  border-radius: 8px;
+  max-height: 320px;
+  overflow-y: auto;
+}
+
+.tb-iot-hub-plan-entry {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 10px 14px;
+  border-bottom: 1px solid rgba(0, 0, 0, 0.08);
+
+  &:last-child {
+    border-bottom: none;
+  }
+}
+
+.tb-iot-hub-plan-entry-main {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  flex-wrap: wrap;
+  min-width: 0;
+}
+
+.tb-iot-hub-plan-entry-name {
+  font-weight: 500;
+  color: rgba(0, 0, 0, 0.87);
+}
+
+.tb-iot-hub-plan-entry-type {
+  font-size: 12px;
+  color: rgba(0, 0, 0, 0.6);
+  background: rgba(0, 0, 0, 0.05);
+  padding: 2px 6px;
+  border-radius: 10px;
+}
+
+.tb-iot-hub-plan-entry-version {
+  font-size: 12px;
+  color: rgba(0, 0, 0, 0.54);
+}
+
+.tb-iot-hub-plan-entry-error {
+  font-size: 12px;
+  color: #b26a00;
+  margin-left: 8px;
+}
+
+.tb-iot-hub-plan-entry-status {
+  font-size: 12px;
+  font-weight: 500;
+  padding: 2px 8px;
+  border-radius: 10px;
+  white-space: nowrap;
+
+  &.tb-status-will-install {
+    color: #1565c0;
+    background: rgba(21, 101, 192, 0.08);
+  }
+
+  &.tb-status-installed {
+    color: #2e7d32;
+    background: rgba(46, 125, 50, 0.08);
+  }
+
+  &.tb-status-missing {
+    color: #b26a00;
+    background: rgba(245, 179, 36, 0.12);
+  }
+}

ui-ngx/src/app/modules/home/components/iot-hub/iot-hub-install-dialog.component.ts

@@ -22,7 +22,14 @@ import { AppState } from '@core/core.state';
 import { DialogComponent } from '@shared/components/dialog.component';
 import { MpItemVersionView } from '@shared/models/iot-hub/iot-hub-version.models';
 import { ItemType, itemTypeTranslations } from '@shared/models/iot-hub/iot-hub-item.models';
-import { SolutionTemplateInstalledItemDescriptor } from '@shared/models/iot-hub/iot-hub-installed-item.models';
+import {
+  InstallPlan,
+  InstallPlanEntry,
+  InstallPlanEntryStatus,
+  InstallPlanResult,
+  IotHubInstalledItemDescriptor,
+  SolutionTemplateInstalledItemDescriptor
+} from '@shared/models/iot-hub/iot-hub-installed-item.models';
 import { IotHubApiService } from '@core/http/iot-hub-api.service';
 import { TranslateService } from '@ngx-translate/core';
 import { EntityType } from '@shared/models/entity-type.models';
@@ -57,8 +64,10 @@ export type InstallState =
   | 'select-entity'
   | 'confirm-overwrite'
   | 'confirm'
+  | 'plan'
   | 'installing'
   | 'success'
+  | 'partial'
   | 'error';
 
 @Component({
@@ -70,6 +79,7 @@ export type InstallState =
 export class TbIotHubInstallDialogComponent extends DialogComponent<TbIotHubInstallDialogComponent> {
 
   ItemType = ItemType;
+  PlanStatus = InstallPlanEntryStatus;
 
   item: MpItemVersionView;
   typeTranslations = itemTypeTranslations;
@@ -80,6 +90,15 @@ export class TbIotHubInstallDialogComponent extends DialogComponent<TbIotHubInst
   selectedEntityId: EntityId | null = null;
   pendingOverwrite: PendingOverwrite | null = null;
 
+  installPlan: InstallPlan | null = null;
+  planSummary: { willInstall: number; alreadyInstalled: number; missing: number } = {
+    willInstall: 0,
+    alreadyInstalled: 0,
+    missing: 0
+  };
+  missingEntries: InstallPlanEntry[] = [];
+  resolvingPlan = false;
+
   private readonly selectEntityConfig: Partial<Record<ItemType, SelectEntityConfig>> = {
     [ItemType.CALCULATED_FIELD]: {
       allowed: [EntityType.DEVICE, EntityType.ASSET, EntityType.DEVICE_PROFILE, EntityType.ASSET_PROFILE],
@@ -155,11 +174,7 @@ export class TbIotHubInstallDialogComponent extends DialogComponent<TbIotHubInst
           this.doInstall();
         }
       },
-      error: (err) => {
-        this.state = 'error';
-        this.errorMessage = err?.error?.message || err?.message ||
-          this.translate.instant('iot-hub.install-error', { name: this.item.name });
-      }
+      error: (err) => this.handleApiError(err)
     });
   }
 
@@ -199,44 +214,130 @@ export class TbIotHubInstallDialogComponent extends DialogComponent<TbIotHubInst
   }
 
   doInstall(): void {
+    // Keep the current state visible (confirm / select-entity / confirm-overwrite) while resolving —
+    // a transient 'resolving-plan' state caused a visible "blink" for items without dependencies.
+    this.resolvingPlan = true;
+    const versionId = this.item.id as string;
+    this.iotHubApiService.resolveInstallPlan(versionId, { ignoreLoading: true }).subscribe({
+      next: (plan) => {
+        this.resolvingPlan = false;
+        const summary = this.summarizePlan(plan);
+        const hasDependencies = plan.entries.length > 1
+          || summary.alreadyInstalled > 0
+          || summary.missing > 0;
+
+        if (!hasDependencies && summary.willInstall === 1) {
+          // Single root version, no deps, nothing to skip — install directly without showing the plan.
+          this.legacyInstall();
+          return;
+        }
+
+        this.installPlan = plan;
+        this.planSummary = summary;
+        this.missingEntries = plan.entries.filter(e => e.status === InstallPlanEntryStatus.MISSING);
+        this.state = 'plan';
+      },
+      error: (err) => {
+        this.resolvingPlan = false;
+        this.handleApiError(err);
+      }
+    });
+  }
+
+  confirmPlan(): void {
+    if (!this.installPlan) {
+      return;
+    }
+    this.state = 'installing';
+    this.iotHubApiService.installPlan(this.installPlan, this.installData(), { ignoreLoading: true }).subscribe({
+      next: (result) => this.handlePlanResult(result),
+      error: (err) => this.handleApiError(err)
+    });
+  }
+
+  private legacyInstall(): void {
     this.state = 'installing';
     const versionId = this.item.id as string;
-    const data = this.selectedEntityId ? { entityId: this.selectedEntityId } : undefined;
-    this.iotHubApiService.installItemVersion(versionId, { ignoreLoading: true }, data).subscribe({
+    this.iotHubApiService.installItemVersion(versionId, { ignoreLoading: true }, this.installData()).subscribe({
       next: (result) => {
-        if (result.success) {
-          if (result.descriptor?.type === 'SOLUTION_TEMPLATE') {
-            const timeout = this.item.dataDescriptor?.installTimeoutMs;
-            const openSolutionDialog = () => {
-              this.dialogRef.close('installed');
-              this.dialog.open(SolutionInstallDialogComponent, {
-                disableClose: true,
-                autoFocus: false,
-                panelClass: ['tb-dialog', 'tb-fullscreen-dialog'],
-                data: { descriptor: result.descriptor as SolutionTemplateInstalledItemDescriptor }
-              });
-            };
-            if (timeout > 0) {
-              setTimeout(openSolutionDialog, timeout);
-            } else {
-              openSolutionDialog();
-            }
-          } else {
-            this.state = 'success';
-            this.entityDetailsUrl = resolveEntityDetailsUrl(result.descriptor, this.item.type);
-          }
-        } else {
+        if (!result.success) {
           this.state = 'error';
           this.errorMessage = result.errorMessage || this.translate.instant('iot-hub.install-error', { name: this.item.name });
+          return;
         }
+        this.handleInstalledDescriptor(result.descriptor);
       },
-      error: (err) => {
-        this.state = 'error';
-        this.errorMessage = err?.error?.message || err?.message || this.translate.instant('iot-hub.install-error', { name: this.item.name });
-      }
+      error: (err) => this.handleApiError(err)
     });
   }
 
+  private summarizePlan(plan: InstallPlan): { willInstall: number; alreadyInstalled: number; missing: number } {
+    const summary = { willInstall: 0, alreadyInstalled: 0, missing: 0 };
+    for (const entry of plan.entries) {
+      switch (entry.status) {
+        case InstallPlanEntryStatus.WILL_INSTALL: summary.willInstall++; break;
+        case InstallPlanEntryStatus.ALREADY_INSTALLED: summary.alreadyInstalled++; break;
+        case InstallPlanEntryStatus.MISSING: summary.missing++; break;
+      }
+    }
+    return summary;
+  }
+
+  private handleApiError(err: any): void {
+    this.state = 'error';
+    this.errorMessage = err?.error?.message || err?.message ||
+      this.translate.instant('iot-hub.install-error', { name: this.item.name });
+  }
+
+  private handlePlanResult(result: InstallPlanResult): void {
+    if (!result.success) {
+      this.state = 'error';
+      this.errorMessage = result.errorMessage || this.translate.instant('iot-hub.install-error', { name: this.item.name });
+      return;
+    }
+    if (this.installPlan) {
+      this.installPlan = { ...this.installPlan, entries: result.entries ?? this.installPlan.entries };
+      this.missingEntries = (result.entries ?? []).filter(e => e.status === InstallPlanEntryStatus.MISSING);
+    }
+    if (result.rootDescriptor) {
+      this.handleInstalledDescriptor(result.rootDescriptor, result.missingItemIds?.length > 0);
+    } else {
+      this.state = (result.missingItemIds?.length ?? 0) > 0 ? 'partial' : 'success';
+    }
+  }
+
+  private handleInstalledDescriptor(descriptor: IotHubInstalledItemDescriptor, partial = false): void {
+    if (descriptor?.type === 'SOLUTION_TEMPLATE') {
+      const timeout = this.item.dataDescriptor?.installTimeoutMs;
+      const openSolutionDialog = () => {
+        this.dialogRef.close('installed');
+        this.dialog.open(SolutionInstallDialogComponent, {
+          disableClose: true,
+          autoFocus: false,
+          panelClass: ['tb-dialog', 'tb-fullscreen-dialog'],
+          data: { descriptor: descriptor as SolutionTemplateInstalledItemDescriptor }
+        });
+      };
+      if (timeout > 0) {
+        setTimeout(openSolutionDialog, timeout);
+      } else {
+        openSolutionDialog();
+      }
+      return;
+    }
+    this.entityDetailsUrl = resolveEntityDetailsUrl(descriptor, this.item.type);
+    this.state = partial ? 'partial' : 'success';
+  }
+
+  private installData(): any | undefined {
+    return this.selectedEntityId ? { entityId: this.selectedEntityId } : undefined;
+  }
+
+  cancelPlan(): void {
+    this.installPlan = null;
+    this.state = 'confirm';
+  }
+
   openEntityDetails(): void {
     if (this.entityDetailsUrl) {
       this.dialogRef.close('installed');
@@ -245,7 +346,8 @@ export class TbIotHubInstallDialogComponent extends DialogComponent<TbIotHubInst
   }
 
   close(): void {
-    this.dialogRef.close(this.state === 'success' ? 'installed' : false);
+    const installedStates: InstallState[] = ['success', 'partial'];
+    this.dialogRef.close(installedStates.includes(this.state) ? 'installed' : false);
   }
 
   cancel(): void {

ui-ngx/src/app/shared/models/iot-hub/iot-hub-installed-item.models.ts

@@ -75,6 +75,37 @@ export interface InstallItemVersionResult {
   descriptor: IotHubInstalledItemDescriptor;
 }
 
+export enum InstallPlanEntryStatus {
+  WILL_INSTALL = 'WILL_INSTALL',
+  ALREADY_INSTALLED = 'ALREADY_INSTALLED',
+  MISSING = 'MISSING'
+}
+
+export interface InstallPlanEntry {
+  itemId: string;
+  versionId: string;
+  name: string;
+  type: string;
+  version: string;
+  status: InstallPlanEntryStatus;
+  root: boolean;
+  errorMessage?: string;
+}
+
+export interface InstallPlan {
+  rootVersionId: string;
+  entries: InstallPlanEntry[];
+}
+
+export interface InstallPlanResult {
+  success: boolean;
+  rolledBack: boolean;
+  errorMessage?: string;
+  rootDescriptor?: IotHubInstalledItemDescriptor;
+  entries: InstallPlanEntry[];
+  missingItemIds: string[];
+}
+
 export interface UpdateItemVersionResult {
   success: boolean;
   entityModified: boolean;

ui-ngx/src/app/shared/models/iot-hub/iot-hub-version.models.ts

@@ -110,6 +110,8 @@ export interface MpItemVersionView {
   installCount: number;
   totalInstallCount: number;
   resources: MpItemVersionResource[];
+  relatedItems?: string[];
+  checksum?: string;
 }
 
 export interface MpItemVersionQueryOptions {

ui-ngx/src/assets/locale/locale.constant-en_US.json

@@ -3831,6 +3831,16 @@
         "goto-main-dashboard": "Go to main dashboard",
         "install-error-title": "Installation Failed",
         "install-error-message": "Failed to install '{{name}}'.",
+        "install-plan-title": "Install '{{name}}' and its dependencies",
+        "install-plan-will-install": "{{count}} item(s) will be installed.",
+        "install-plan-will-update": "{{count}} item(s) will be updated.",
+        "install-plan-missing-warning": "{{count}} required item(s) could not be found on the marketplace. '{{ name }}' may not work fully without them.",
+        "install-plan-status-will": "Install",
+        "install-plan-status-installed": "Update",
+        "install-plan-status-missing": "Missing",
+        "install-plan-confirm": "Install",
+        "install-partial-title": "Installed with warnings",
+        "install-partial-desc": "'{{name}}' was installed, but some required items were missing.",
         "check-for-updates": "Check for updates",
         "updates": "Updates",
         "up-to-date": "Up to date",