dashboard-shell-shell 1.0.10000011122 → 3.0.5-test.1

package/models/chart.js

@@ -1,9 +1,12 @@
-import { compatibleVersionsFor } from '@shell/store/catalog';
+import { compatibleVersionsFor, APP_UPGRADE_STATUS } from '@shell/store/catalog';
 import {
-  REPO_TYPE, REPO, CHART, VERSION, _FLAGGED, HIDE_SIDE_NAV
+  REPO_TYPE, REPO, CHART, VERSION, _FLAGGED, HIDE_SIDE_NAV, CATEGORY, TAG
 } from '@shell/config/query-params';
 import { BLANK_CLUSTER } from '@shell/store/store-types.js';
 import SteveModel from '@shell/plugins/steve/steve-class';
+import { CATALOG, ZERO_TIME } from '@shell/config/types';
+import { CATALOG as CATALOG_ANNOTATIONS } from '@shell/config/labels-annotations';
+import day from 'dayjs';
 
 export default class Chart extends SteveModel {
   queryParams(from, hideSideNav) {
@@ -47,4 +50,156 @@ export default class Chart extends SteveModel {
       query,
     });
   }
+
+  /**
+   * Returns the list of installed apps that match this chart by:
+   * - chart name
+   * - repository name
+   * - and either:
+   *   - the home URL matches the latest version’s home URL
+   *   - or version + home URL match any other known version
+   *
+   * Inverse logic of `matchingCharts` in `catalog.cattle.io.app.js`.
+   *
+   * @returns {Array<Object>} List of matching installed app objects.
+   */
+  get matchingInstalledApps() {
+    const latestVersion = this.versions?.[0] || [];
+    const appHome = latestVersion?.home;
+    const installedApps = this.$rootGetters['cluster/all'](CATALOG.APP);
+
+    return installedApps.filter((installedApp) => {
+      const metadata = installedApp?.spec?.chart?.metadata;
+      const name = metadata?.name;
+      const version = metadata?.version;
+      const home = metadata?.home;
+
+      const repoName = metadata?.annotations?.[CATALOG_ANNOTATIONS.SOURCE_REPO_NAME] ||
+                       installedApp?.metadata?.labels?.[CATALOG_ANNOTATIONS.CLUSTER_REPO_NAME];
+
+      // name and repo should match
+      if (name !== this.chartName || !repoName || repoName !== this.repoName) {
+        return false;
+      }
+
+      // match by comparing home URL in the latest version vs home URL from the installed app
+      if (appHome && home === appHome) {
+        return true;
+      }
+
+      // match by version + home for the rest
+      return this.versions?.some((v) => v.version === version && home === appHome);
+    });
+  }
+
+  /**
+   * Determines if the chart is installed by checking if exactly one matching installed app is found.
+   *
+   * @returns {boolean} `true` if the chart is currently installed.
+   */
+  get isInstalled() {
+    return this.matchingInstalledApps.length === 1;
+  }
+
+  /**
+   * Determines if the installed app has a single available upgrade.
+   * Requires the chart to be installed.
+   *
+   * @returns {boolean} `true` if the app is installed and has a single upgrade available.
+   */
+  get upgradeable() {
+    return this.isInstalled && this.matchingInstalledApps[0].upgradeAvailable === APP_UPGRADE_STATUS.SINGLE_UPGRADE;
+  }
+
+  /**
+   * Builds structured metadata for display in RcItemCard.vue:
+   * - Sub-header (version and last updated)
+   * - Footer (repository, categories, tags)
+   * - Status indicators (e.g. deprecated, upgradeable, installed)
+   *
+   * @returns {Object} Card content object with `subHeaderItems`, `footerItems`, and `statuses` arrays.
+   */
+  get cardContent() {
+    if (!this._cardContent) {
+      const latestVersion = this.versions?.[0] || {};
+      const subHeaderItems = [];
+
+      if (latestVersion) {
+        const hasZeroTime = latestVersion.created === ZERO_TIME;
+
+        subHeaderItems.push({
+          icon:        'icon-version-alt',
+          iconTooltip: { key: 'tableHeaders.version' },
+          label:       latestVersion.version
+        });
+
+        const lastUpdatedItem = {
+          icon:        'icon-refresh-alt',
+          iconTooltip: { key: 'tableHeaders.lastUpdated' },
+          label:       hasZeroTime ? this.t('generic.na') : day(latestVersion.created).format('MMM D, YYYY')
+        };
+
+        if (hasZeroTime) {
+          lastUpdatedItem.labelTooltip = this.t('catalog.charts.appChartCard.subHeaderItem.missingVersionDate');
+        }
+
+        subHeaderItems.push(lastUpdatedItem);
+      }
+
+      const footerItems = [
+        {
+          type:        REPO,
+          icon:        'icon-repository-alt',
+          iconTooltip: { key: 'tableHeaders.repoName' },
+          labels:      [this.repoNameDisplay]
+        }
+      ];
+
+      if (this.categories.length) {
+        footerItems.push( {
+          type:        CATEGORY,
+          icon:        'icon-category-alt',
+          iconTooltip: { key: 'generic.category' },
+          labels:      this.categories
+        });
+      }
+
+      if (this.tags.length) {
+        footerItems.push({
+          type:        TAG,
+          icon:        'icon-tag-alt',
+          iconTooltip: { key: 'generic.tags' },
+          labels:      this.tags
+        });
+      }
+
+      const statuses = [];
+
+      if (this.deprecated) {
+        statuses.push({
+          icon: 'icon-alert-alt', color: 'error', tooltip: { key: 'generic.deprecated' }
+        });
+      }
+
+      if (this.upgradeable) {
+        statuses.push({
+          icon: 'icon-upgrade-alt', color: 'info', tooltip: { key: 'generic.upgradeable' }
+        });
+      }
+
+      if (this.isInstalled) {
+        statuses.push({
+          icon: 'icon-confirmation-alt', color: 'success', tooltip: { key: 'generic.installed' }
+        });
+      }
+
+      this._cardContent = {
+        subHeaderItems,
+        footerItems,
+        statuses
+      };
+    }
+
+    return this._cardContent;
+  }
 }

package/models/cluster/node.js

@@ -227,7 +227,7 @@ export default class ClusterNode extends SteveModel {
   }
 
   get podCapacity() {
-    return Number.parseInt(this.status.capacity?.pods);
+    return parseSi(this.status.capacity?.pods);
   }
 
   get podConsumed() {
@@ -408,6 +408,7 @@ export default class ClusterNode extends SteveModel {
   }
 
   get pods() {
+    // This fetches all pods that are in the store, rather than all pods in the cluster
     const allPods = this.$rootGetters['cluster/all'](POD);
 
     return allPods.filter((pod) => pod.spec.nodeName === this.name);

package/models/cluster.js

@@ -33,10 +33,40 @@ export default class NormanCluster extends NormanModel {
     return !!(this.systemAnnotations || []).length;
   }
 
+  /**
+   * Return the namespace of the v1 prov cluster.
+   *
+   * Used to construct the prov cluster id
+   *
+   * objectset.rio.cattle.io/owner-namespace annotation is applied to v3 clusters that were automatically created following the creation of a v1 prov cluster
+   */
+  get provisioningClusterNs() {
+    return this.annotations?.['objectset.rio.cattle.io/owner-namespace'] || 'fleet-default';
+  }
+
+  /**
+   * Return the name of the v1 prov cluster (note - not the human name, but usually is)
+   *
+   * Used to construct the prov cluster id.
+   *
+   * It could be two different forms. If the v1 prov cluster was created ..
+   * - automatically following the creation of a v3 cluster = id is the v3 cluster id
+   * - directly by the user = id is the (roughly) human name, which is this.id
+   *
+   * objectset.rio.cattle.io/owner-namespace annotation is applied to v3 clusters that were automatically created following the creation of a v1 prov cluster
+   *
+   */
+  get provisioningClusterName() {
+    return this.annotations?.['objectset.rio.cattle.io/owner-name'] || this.id;
+  }
+
+  get provisioningClusterId() {
+    return `${ this.provisioningClusterNs }/${ this.provisioningClusterName }`;
+  }
+
   waitForProvisioning(timeout = 60000, interval) {
     return this.waitForTestFn(() => {
-      const ns = this.annotations['objectset.rio.cattle.io/owner-namespace'] || 'fleet-default';
-      const id = `${ ns }/${ this.id }`;
+      const id = this.provisioningClusterId;
 
       return id && !!this.$rootGetters['management/byId'](CAPI.RANCHER_CLUSTER, id);
     }, this.$rootGetters['i18n/t']('cluster.managementTimeout'), timeout, interval);

package/models/cluster.x-k8s.io.machinedeployment.js

@@ -125,7 +125,7 @@ export default class CapiMachineDeployment extends SteveModel {
       return;
     }
 
-    const initialValue = this.cluster.toJSON();
+    const initialValue = this.cluster;
 
     this.inClusterSpec.quantity += delta;
 
@@ -145,7 +145,16 @@ export default class CapiMachineDeployment extends SteveModel {
         let errors = exceptionToErrorsArray(err);
 
         if ( err.status === 409 && depth < 2 ) {
-          const conflicts = await handleConflict(initialValue, value, liveModel, this.$rootGetters, { dispatch: this.$dispatch }, 'management');
+          const conflicts = await handleConflict(
+            initialValue,
+            value,
+            liveModel,
+            {
+              dispatch: this.$dispatch,
+              getters:  this.$rootGetters
+            },
+            'management'
+          );
 
           if ( conflicts === false ) {
             // It was automatically figured out, save again

package/models/{cis.cattle.io.clusterscan.js → compliance.cattle.io.clusterscan.js}

@@ -1,5 +1,5 @@
-import { NAME as PRODUCT_NAME } from '@shell/config/product/cis';
-import { CIS } from '@shell/config/types';
+import { NAME as PRODUCT_NAME } from '@shell/config/product/compliance';
+import { COMPLIANCE } from '@shell/config/types';
 import { findBy } from '@shell/utils/array';
 import { downloadFile, generateZip } from '@shell/utils/download';
 import { get, isEmpty } from '@shell/utils/object';
@@ -53,7 +53,7 @@ export default class ClusterScan extends SteveModel {
       action:  'downloadLatestReport',
       enabled: this.hasReport,
       icon:    'icon icon-fw icon-download',
-      label:   t('cis.downloadReport'),
+      label:   t('compliance.downloadReport'),
       total:   1,
     };
 
@@ -61,7 +61,7 @@ export default class ClusterScan extends SteveModel {
       action:  'downloadAllReports',
       enabled: this.hasReport,
       icon:    'icon icon-fw icon-download',
-      label:   t('cis.downloadAllReports'),
+      label:   t('compliance.downloadAllReports'),
       total:   1,
     };
 
@@ -69,7 +69,7 @@ export default class ClusterScan extends SteveModel {
       out.unshift({ divider: true });
       if (this.spec?.scheduledScanConfig?.cronSchedule) {
         out.unshift(downloadAllReports);
-        downloadReport.label = t('cis.downloadLatestReport');
+        downloadReport.label = t('compliance.downloadLatestReport');
       }
       out.unshift(downloadReport);
     }
@@ -92,7 +92,7 @@ export default class ClusterScan extends SteveModel {
   get hasReports() {
     const { relationships = [] } = this.metadata;
 
-    const reportRel = findBy(relationships, 'toType', CIS.REPORT);
+    const reportRel = findBy(relationships, 'toType', COMPLIANCE.REPORT);
 
     return !!reportRel;
   }
@@ -100,7 +100,7 @@ export default class ClusterScan extends SteveModel {
   async getReports() {
     const owned = await this.findOwned();
 
-    const reports = owned.filter((obj) => obj.type === CIS.REPORT) || [];
+    const reports = owned.filter((obj) => obj.type === COMPLIANCE.REPORT) || [];
 
     return sortBy(reports, 'metadata.creationTimestamp', true);
   }
@@ -158,7 +158,7 @@ export default class ClusterScan extends SteveModel {
       return {
         name:   'c-cluster-product-resource-id',
         params: {
-          resource: CIS.CLUSTER_SCAN_PROFILE,
+          resource: COMPLIANCE.CLUSTER_SCAN_PROFILE,
           product:  PRODUCT_NAME,
           id:       this.status?.lastRunScanProfileName
         }

package/models/{cis.cattle.io.clusterscanbenchmark.js → compliance.cattle.io.clusterscanbenchmark.js}

@@ -3,7 +3,7 @@ import SteveModel from '@shell/plugins/steve/steve-class';
 
 export default class ClusterScanBenchmark extends SteveModel {
   warnDeletionMessage(toRemove = []) {
-    return this.$rootGetters['i18n/t']('cis.deleteBenchmarkWarning', { count: toRemove.length });
+    return this.$rootGetters['i18n/t']('compliance.deleteBenchmarkWarning', { count: toRemove.length });
   }
 
   get isDefault() {

package/models/{cis.cattle.io.clusterscanprofile.js → compliance.cattle.io.clusterscanprofile.js}

@@ -1,11 +1,11 @@
 
 import SteveModel from '@shell/plugins/steve/steve-class';
-import { NAME as PRODUCT_NAME } from '@shell/config/product/cis';
-import { CIS } from '@shell/config/types';
+import { NAME as PRODUCT_NAME } from '@shell/config/product/compliance';
+import { COMPLIANCE } from '@shell/config/types';
 
-export default class CISProfile extends SteveModel {
+export default class ComplianceProfile extends SteveModel {
   warnDeletionMessage(toRemove = []) {
-    return this.$rootGetters['i18n/t']('cis.deleteProfileWarning', { count: toRemove.length });
+    return this.$rootGetters['i18n/t']('compliance.deleteProfileWarning', { count: toRemove.length });
   }
 
   get numberTestsSkipped() {
@@ -19,7 +19,7 @@ export default class CISProfile extends SteveModel {
       return {
         name:   'c-cluster-product-resource-id',
         params: {
-          resource: CIS.BENCHMARK,
+          resource: COMPLIANCE.BENCHMARK,
           product:  PRODUCT_NAME,
           id:       this.spec?.benchmarkVersion
         }

package/models/{cis.cattle.io.clusterscanreport.js → compliance.cattle.io.clusterscanreport.js}

@@ -1,7 +1,7 @@
 import { compare } from '@shell/utils/sort';
 import SteveModel from '@shell/plugins/steve/steve-class';
 
-export default class CISReport extends SteveModel {
+export default class ComplianceReport extends SteveModel {
   get aggregatedTests() {
     const json = this.parsedReport;
     const results = json?.results;

package/models/fleet-application.js

@@ -0,0 +1,297 @@
+import { matching, convertSelectorObj } from '@shell/utils/selector';
+import isEmpty from 'lodash/isEmpty';
+import { escapeHtml } from '@shell/utils/string';
+import { FLEET, MANAGEMENT } from '@shell/config/types';
+import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
+import { addObject, addObjects, findBy } from '@shell/utils/array';
+import SteveModel from '@shell/plugins/steve/steve-class';
+import { mapStateToEnum, primaryDisplayStatusFromCount, STATES_ENUM } from '@shell/plugins/dashboard-store/resource-class';
+import FleetUtils from '@shell/utils/fleet';
+
+function normalizeStateCounts(data) {
+  if (isEmpty(data)) {
+    return {
+      total:  0,
+      states: {},
+    };
+  }
+  const { desiredReady, ...rest } = data ;
+  const states = Object.entries(rest).reduce((res, [key, value]) => {
+    res[mapStateToEnum(key)] = value;
+
+    return res;
+  }, {});
+
+  return {
+    total: desiredReady,
+    states,
+  };
+}
+
+export default class FleetApplication extends SteveModel {
+  get currentUser() {
+    return this.$rootGetters['auth/v3User'] || {};
+  }
+
+  pause() {
+    this.spec.paused = true;
+    this.save();
+  }
+
+  unpause() {
+    this.spec.paused = false;
+    this.save();
+  }
+
+  goToClone() {
+    if (this.metadata?.labels?.[FLEET_ANNOTATIONS.CREATED_BY_USER_ID]) {
+      delete this.metadata.labels[FLEET_ANNOTATIONS.CREATED_BY_USER_ID];
+    }
+
+    if (this.metadata?.labels?.[FLEET_ANNOTATIONS.CREATED_BY_USER_NAME]) {
+      delete this.metadata.labels[FLEET_ANNOTATIONS.CREATED_BY_USER_NAME];
+    }
+
+    super.goToClone();
+  }
+
+  get state() {
+    if (this.spec?.paused === true) {
+      return 'paused';
+    }
+
+    return this.metadata?.state?.name || 'unknown';
+  }
+
+  get targetClusters() {
+    const workspace = this.$getters['byId'](FLEET.WORKSPACE, this.metadata.namespace);
+    const clusters = workspace?.clusters || [];
+    const groups = workspace?.clusterGroups || [];
+
+    if (workspace?.id === 'fleet-local') {
+      // should we be getting the clusters from workspace.clusters instead of having to rely on the groups,
+      // which takes an additional request to be done on the Fleet dashboard screen?
+      const local = findBy(groups, 'id', 'fleet-local/default');
+
+      if (local) {
+        return local.targetClusters;
+      }
+
+      return [];
+    }
+
+    if (!this.spec.targets) {
+      return [];
+    }
+
+    const out = [];
+
+    for (const tgt of this.spec.targets) {
+      if (tgt.clusterName) {
+        const cluster = findBy(clusters, 'metadata.name', tgt.clusterName);
+
+        if (cluster) {
+          addObject(out, cluster);
+        }
+      } else if (tgt.clusterGroup) {
+        const group = findBy(groups, {
+          'metadata.namespace': this.metadata.namespace,
+          'metadata.name':      tgt.clusterGroup,
+        });
+
+        if (group) {
+          addObjects(out, group.targetClusters);
+        }
+      } else if (tgt.clusterGroupSelector) {
+        const expressions = convertSelectorObj(tgt.clusterGroupSelector);
+        const matchingGroups = matching(groups, expressions);
+
+        for (const group of matchingGroups) {
+          addObjects(out, group.targetClusters);
+        }
+      } else if (tgt.clusterSelector) {
+        const expressions = convertSelectorObj(tgt.clusterSelector);
+        const matchingClusters = matching(clusters, expressions);
+
+        addObjects(out, matchingClusters);
+      }
+    }
+
+    return out;
+  }
+
+  get targetInfo() {
+    const mode = FleetUtils.Application.getTargetMode(this.spec.targets || [], this.metadata.namespace);
+
+    return {
+      mode,
+      modeDisplay: this.t(`fleet.gitRepo.targetDisplay."${ mode }"`),
+    };
+  }
+
+  get groupByLabel() {
+    const name = this.metadata.namespace;
+
+    if (name) {
+      return this.$rootGetters['i18n/t']('resourceTable.groupLabel.workspace', { name: escapeHtml(name) });
+    } else {
+      return this.$rootGetters['i18n/t']('resourceTable.groupLabel.notInAWorkspace');
+    }
+  }
+
+  get allResourceStatuses() {
+    return normalizeStateCounts(this.status?.resourceCounts || {});
+  }
+
+  statusResourceCountsForCluster(clusterId) {
+    if (!this.targetClusters.some((c) => c.id === clusterId)) {
+      return {};
+    }
+
+    return this.status?.perClusterResourceCounts[clusterId] || { desiredReady: 0 };
+  }
+
+  get resourcesStatuses() {
+    if (isEmpty(this.status?.resources)) {
+      return [];
+    }
+
+    const clusters = (this.targetClusters || []).reduce((res, c) => {
+      res[c.id] = c;
+
+      return res;
+    }, {});
+
+    const resources = this.status?.resources?.reduce((acc, resourceInfo) => {
+      const { perClusterState, ...resource } = resourceInfo;
+
+      if (Object.entries(perClusterState).length === 0) {
+        (this.targetClusters || []).forEach((cluster) => {
+          acc.push(Object.assign({}, resource, { clusterId: cluster.id, state: resource.state }));
+        });
+      } else {
+        Object.entries(perClusterState).forEach(([state, clusterIds]) => {
+          clusterIds.filter((id) => !!clusters[id]).forEach((clusterId) => {
+            acc.push(Object.assign({}, resource, { clusterId, state }));
+          });
+        });
+      }
+
+      return acc;
+    }, []);
+
+    return resources.map((r) => {
+      const { namespace, name, clusterId } = r;
+      const type = FleetUtils.resourceType(r);
+      const c = clusters[clusterId];
+
+      return {
+        key: `${ clusterId }-${ type }-${ namespace }-${ name }`,
+
+        // Needed?
+        id: FleetUtils.resourceId(r),
+        type,
+        clusterId,
+
+        // columns, see FleetResources.vue
+        state:       mapStateToEnum(r.state),
+        clusterName: c.nameDisplay,
+        apiVersion:  r.apiVersion,
+        kind:        r.kind,
+        name,
+        namespace,
+
+        // other properties
+        detailLocation: FleetUtils.detailLocation(r, c.metadata.labels[FLEET_ANNOTATIONS.CLUSTER_NAME]),
+      };
+    });
+  }
+
+  get clusterInfo() {
+    const ready = this.status?.readyClusters || 0;
+    const total = this.status?.desiredReadyClusters || 0;
+
+    return {
+      ready,
+      unready: total - ready,
+      total,
+    };
+  }
+
+  clusterState(clusterId) {
+    const resourceCounts = this.statusResourceCountsForCluster(clusterId);
+
+    return primaryDisplayStatusFromCount(resourceCounts) || STATES_ENUM.ACTIVE;
+  }
+
+  get authorId() {
+    return this.metadata?.labels?.[FLEET_ANNOTATIONS.CREATED_BY_USER_ID];
+  }
+
+  get author() {
+    if (this.authorId) {
+      return this.$rootGetters['management/byId'](MANAGEMENT.USER, this.authorId);
+    }
+
+    return null;
+  }
+
+  get createdBy() {
+    const displayName = this.metadata?.labels?.[FLEET_ANNOTATIONS.CREATED_BY_USER_NAME];
+
+    if (!displayName) {
+      return null;
+    }
+
+    return {
+      displayName,
+      location: !this.author ? null : {
+        name:   'c-cluster-product-resource-id',
+        params: {
+          cluster:  '_',
+          product:  'auth',
+          resource: MANAGEMENT.USER,
+          id:       this.author.id,
+        }
+      }
+    };
+  }
+
+  get showCreatedBy() {
+    return !!this.createdBy;
+  }
+
+  get clustersList() {
+    return this.$getters['all'](FLEET.CLUSTER);
+  }
+
+  get readyClusters() {
+    return this.status?.readyClusters || 0;
+  }
+
+  get meta() {
+    return this.currentRoute()?.meta || {};
+  }
+
+  get _detailLocation() {
+    return {
+      ...super._detailLocation,
+      name: this.meta.detailLocation || super._detailLocation.name
+    };
+  }
+
+  get doneOverride() {
+    return {
+      ...super.listLocation,
+      name: this.meta.doneOverride || super.listLocation.name
+    };
+  }
+
+  get doneRoute() {
+    return this.doneOverride?.name;
+  }
+
+  get parentNameOverride() {
+    return this.$rootGetters['i18n/t'](`typeLabel."${ FLEET.APPLICATION }"`, { count: 1 })?.trim();
+  }
+}

package/models/fleet.cattle.io.bundle.js

@@ -1,6 +1,5 @@
 import { escapeHtml, ucFirst } from '@shell/utils/string';
 import SteveModel from '@shell/plugins/steve/steve-class';
-import typeHelper from '@shell/utils/type-helpers';
 import { addObject, addObjects, findBy } from '@shell/utils/array';
 import { FLEET, MANAGEMENT } from '@shell/config/types';
 import { FLEET as FLEET_ANNOTATIONS } from '@shell/config/labels-annotations';
@@ -11,18 +10,20 @@ export default class FleetBundle extends SteveModel {
     return this.status?.conditions?.[0].lastUpdateTime;
   }
 
-  get bundleType() {
-    if (typeHelper.memberOfObject(this.spec, 'helm')) {
-      return 'helm';
-    }
+  get repoName() {
+    const labels = this.metadata?.labels || {};
 
-    return '';
+    return labels[FLEET_ANNOTATIONS.REPO_NAME];
   }
 
-  get repoName() {
+  get helmName() {
     const labels = this.metadata?.labels || {};
 
-    return labels[FLEET_ANNOTATIONS.REPO_NAME];
+    return labels[FLEET_ANNOTATIONS.HELM_NAME];
+  }
+
+  get appSourceName() {
+    return this.helmName || this.repoName;
   }
 
   get targetClusters() {