dashboard-shell-shell 3.0.2-test.20250913 → 3.0.5-logTest.2

package/mixins/__tests__/brand.spec.ts

@@ -0,0 +1,170 @@
+import { mount } from '@vue/test-utils';
+import { CATALOG, MANAGEMENT } from '@shell/config/types';
+import Brand from '@shell/mixins/brand';
+
+describe('brandMixin', () => {
+  const createWrapper = (vaiOn = false) => {
+    const Component = {
+      template: '<div></div>',
+      mixins:   [Brand],
+    };
+
+    const data = {
+      apps: null, haveAppsAndSettings: null, canPaginate: false
+    };
+
+    const store = {
+      dispatch: (action, ...args) => {
+        switch (action) {
+        case 'management/findAll':
+          if (args[0] === MANAGEMENT.SETTING) {
+            return [];
+          }
+          if (args[0] === CATALOG.APP) {
+            return [];
+          }
+          break;
+        }
+      },
+      getters: {
+        'auth/loggedIn':        () => true,
+        'auth/fromHeader':      () => false,
+        'management/byId':      () => undefined,
+        'management/canList':   () => () => true,
+        'management/schemaFor': (type: string) => {
+          switch (type) {
+          case MANAGEMENT.SETTING:
+            return { linkFor: () => undefined };
+          }
+        },
+        'management/generation':        () => undefined,
+        'management/paginationEnabled': () => vaiOn,
+        'management/all':               (type: string) => {
+          switch (type) {
+          case MANAGEMENT.SETTING:
+            return [];
+          }
+        },
+      }
+    };
+
+    const wrapper = mount(
+      Component,
+      {
+        data:   () => data,
+        global: { mocks: { $store: store } }
+      });
+    const spyManagementFindAll = jest.spyOn(store, 'dispatch');
+
+    return {
+      wrapper,
+      store,
+      spyManagementFindAll,
+    };
+  };
+
+  describe('should make correct requests', () => {
+    it('vai off', async() => {
+      const { wrapper, spyManagementFindAll } = createWrapper(false);
+
+      // NOTE - wrapper.vm.$options.fetch() doesn't work
+      await wrapper.vm.$options.fetch.apply(wrapper.vm);
+
+      // wrapper.vm.$nextTick();
+      expect(spyManagementFindAll).toHaveBeenNthCalledWith(1, 'management/findAll', {
+        type: MANAGEMENT.SETTING,
+        opt:  {
+          load: 'multi', redirectUnauthorized: false, url: `/v1/${ MANAGEMENT.SETTING }s`
+        }
+      });
+      expect(spyManagementFindAll).toHaveBeenNthCalledWith(2, 'management/findAll', { type: CATALOG.APP });
+    });
+
+    it('vai on', async() => {
+      const { wrapper, spyManagementFindAll } = createWrapper(true);
+
+      // NOTE - wrapper.vm.$options.fetch() doesn't work
+      await wrapper.vm.$options.fetch.apply(wrapper.vm);
+
+      expect(spyManagementFindAll).toHaveBeenNthCalledWith(1, 'management/findAll', {
+        type: MANAGEMENT.SETTING,
+        opt:  {
+          load: 'multi', url: `/v1/${ MANAGEMENT.SETTING }s`, redirectUnauthorized: false
+        }
+      });
+      expect(spyManagementFindAll).toHaveBeenNthCalledWith(2, 'management/findPage', {
+        type: CATALOG.APP,
+        opt:  {
+          pagination: {
+            filters: [{
+              equals: true,
+              fields: [{
+                equals: true, exact: true, exists: false, field: 'metadata.name', value: 'rancher-csp-adapter'
+              }, {
+                equals: true, exact: true, exists: false, field: 'metadata.name', value: 'rancher-csp-billing-adapter'
+              }],
+              param: 'filter'
+            }],
+            labelSelector:        undefined,
+            page:                 null,
+            pageSize:             null,
+            projectsOrNamespaces: [],
+            sort:                 []
+          }
+        }
+      });
+    });
+  });
+
+  describe('cspAdapter', () => {
+    it('should have correct csp values (off)', async() => {
+      const { wrapper, store } = createWrapper();
+
+      const spyManagementFindAll = jest.spyOn(store, 'dispatch').mockImplementation((_, options) => {
+        const { type } = options as any;
+
+        if (type === MANAGEMENT.SETTING) {
+          return Promise.resolve([]);
+        }
+        if (type === CATALOG.APP) {
+          return Promise.resolve([]);
+        }
+
+        return Promise.reject(new Error('reason'));
+      });
+
+      // NOTE - wrapper.vm.$options.fetch() doesn't work
+      await wrapper.vm.$options.fetch.apply(wrapper.vm, []);
+
+      expect(spyManagementFindAll).toHaveBeenCalledTimes(2);
+
+      expect(wrapper.vm.canCalcCspAdapter).toBeTruthy();
+      expect(wrapper.vm.cspAdapter).toBeFalsy();
+    });
+
+    it.each(['rancher-csp-adapter', 'rancher-csp-billing-adapter'])('should have correct csp values (on - %p )', async(chartName) => {
+      const { wrapper, store } = createWrapper();
+
+      const spyManagementFindAll = jest.spyOn(store, 'dispatch').mockImplementation((_, options) => {
+        const { type } = options as any;
+
+        if (type === MANAGEMENT.SETTING) {
+          return Promise.resolve([]);
+        }
+        if (type === CATALOG.APP) {
+          return Promise.resolve([{ metadata: { name: chartName } }]);
+        }
+
+        return Promise.reject(new Error('reason'));
+      });
+
+      // NOTE - wrapper.vm.$options.fetch() doesn't work
+      await wrapper.vm.$options.fetch.apply(wrapper.vm, []);
+
+      expect(spyManagementFindAll).toHaveBeenCalledTimes(2);
+
+      expect(wrapper.vm.canCalcCspAdapter).toBeTruthy();
+      expect(wrapper.vm.cspAdapter).toBeTruthy();
+    });
+  });
+});

package/mixins/auth-config.js

@@ -307,7 +307,14 @@ export default {
 
         // KeyCloakOIDCConfig --> OIDCConfig
         this.model.rancherUrl = `${ serverUrl }/verify-auth`;
-        this.model.scope = this.model.id === 'keycloakoidc' ? BASE_SCOPES.keycloakoidc[0] : BASE_SCOPES.genericoidc[0];
+
+        // If there are base scopes defined for this provider, use those
+        if (Array.isArray(BASE_SCOPES[this.model.id])) {
+          this.model.scope = BASE_SCOPES[this.model.id][0];
+        } else {
+          // Default if base scopes not defined for this auth provider
+          this.model.scope = BASE_SCOPES.genericoidc[0];
+        }
         break;
       }
 

package/mixins/brand.js

@@ -1,39 +1,38 @@
 import { mapGetters } from 'vuex';
-import { CATALOG, MANAGEMENT } from '@shell/config/types';
+import { MANAGEMENT } from '@shell/config/types';
 import { SETTING } from '@shell/config/settings';
 import { createCssVars } from '@shell/utils/color';
 import { setTitle } from '@shell/config/private-label';
 import { setFavIcon, haveSetFavIcon } from '@shell/utils/favicon';
-
-const cspAdaptorApp = ['rancher-csp-adapter', 'rancher-csp-billing-adapter'];
-
-export const hasCspAdapter = (apps) => {
-  return apps?.find((a) => cspAdaptorApp.includes(a.metadata?.name));
-};
+import { allHash } from '@shell/utils/promise';
+import { fetchInitialSettings } from '@shell/utils/settings';
+import CspAdapterUtils from '@shell/utils/cspAdaptor';
 
 export default {
   async fetch() {
-    // For the login page, the schemas won't be loaded - we don't need the apps in this case
     try {
-      if (this.$store.getters['management/canList'](CATALOG.APP)) {
-        this.apps = await this.$store.dispatch('management/findAll', { type: CATALOG.APP });
-      }
-    } catch (e) {}
+      const res = await allHash({
+        // Ensure we read the settings even when we are not authenticated
+        globalSettings: fetchInitialSettings(this.$store),
+        apps:           CspAdapterUtils.fetchCspAdaptorApp(this.$store),
+      });
 
-    // Ensure we read the settings even when we are not authenticated
-    try {
       // The favicon is implicitly dependent on the initial settings having already been fetched
       if (!haveSetFavIcon()) {
         setFavIcon(this.$store);
       }
-    } catch (e) {}
+
+      this.apps = res.apps;
+    } catch (e) { }
 
     // Setting this up front will remove `computed` churn, and we only care that we've initialised them
     this.haveAppsAndSettings = !!this.apps && !!this.globalSettings;
   },
 
   data() {
-    return { apps: null, haveAppsAndSettings: null };
+    return {
+      apps: null, haveAppsAndSettings: null, canPaginate: false
+    };
   },
 
   computed: {
@@ -87,7 +86,7 @@ export default {
       // Note! this used to be `findBy(this.app)` however for that case we lost reactivity on the collection
       // (computed fires before fetch, fetch happens and update apps, computed would not fire again - even with vue.set)
       // So use `.find` in method instead
-      return hasCspAdapter(this.apps);
+      return CspAdapterUtils.hasCspAdapter({ $store: this.$store, apps: this.apps });
     },
 
     canCalcCspAdapter() {

package/mixins/create-edit-view/impl.js

@@ -117,7 +117,16 @@ export default {
     // If they are resolved, return a false-y value
     // Else they can't be resolved, return an array of errors to show to the user.
     async conflict() {
-      return await handleConflict(this.initialValue.toJSON(), this.value, this.liveValue, this.$store.getters, this.$store, this.storeOverride || this.$store.getters['currentStore'](this.value.type));
+      return await handleConflict(
+        this.initialValue,
+        this.value,
+        this.liveValue,
+        {
+          dispatch: this.$store.dispatch,
+          getters:  this.$store.getters
+        },
+        this.storeOverride || this.$store.getters['currentStore'](this.value.type)
+      );
     },
 
     async save(buttonDone, url, depth = 0) {
@@ -161,6 +170,16 @@ export default {
       } catch (err) {
         // This exception handles errors from the `request` action when it receives a failed http request. The `err` object could be from the action's error handler (raw http response object containing `status`) or thrown later on given the response of the action (a massaged object containing `_status`). TBD why one 409 triggers the error handler and another does not.
         const IS_ERR_409 = err.status === 409 || err._status === 409;
+        
+        const IS_ERR_403 = err.status === 403 || err._status === 403;
+
+        if (err.message === '' && err.fieldName && err.code) {
+          err.message = err.code + ' ' + err.fieldName
+        }
+        
+        if (IS_ERR_403) {
+          err.message = '权限不足'
+        }
 
         // Conflict, the resource being edited has changed since starting editing
         if (IS_ERR_409 && depth === 0 && this.isEdit) {

package/mixins/create-edit-view/index.js

@@ -44,5 +44,10 @@ export default defineComponent({
       type:    Boolean,
       default: false,
     },
+
+    useTabbedHash: {
+      type:    Boolean,
+      default: undefined
+    }
   },
 });

package/mixins/preset.js

@@ -0,0 +1,100 @@
+import { watch } from 'vue';
+import { dasherize } from '@shell/utils/string';
+import { NORMAN } from '@shell/config/types';
+
+export default {
+  data() {
+    return {
+      _init:   [],
+      presets: {},
+    };
+  },
+
+  mounted() {
+    this.presetKey = dasherize(this.$options.name || '');
+
+    const version = this.presetVersion;
+
+    if (!version) {
+      console.warn('Preset: version not found, skip.'); // eslint-disable-line no-console
+
+      return;
+    }
+
+    let presets = null;
+
+    try {
+      presets = JSON.parse(window.localStorage.getItem(this.presetKey));
+    } catch (error) {
+      console.warn(`Preset: load presets failed, invalid presets [${ this.presetKey }]`); // eslint-disable-line no-console
+    }
+
+    if (presets?.data && presets?.user === this.user && presets?.version === version) {
+      this.presets = presets;
+
+      return;
+    }
+
+    this.presets = {
+      data: {},
+      user: this.user,
+      version
+    };
+  },
+
+  computed: {
+    user() {
+      const principal = this.$store.getters['rancher/byId'](NORMAN.PRINCIPAL, this.$store.getters['auth/principalId']) || {};
+
+      return principal.loginName;
+    }
+  },
+
+  methods: {
+    preset(key, type) {
+      if (this._init.includes(key)) {
+        return;
+      }
+
+      this._init.push(key);
+
+      if (!this.presetVersion) {
+        return;
+      }
+
+      if (!this.presetKey) {
+        return;
+      }
+
+      if (!this.presets?.data) {
+        return;
+      }
+
+      if (this[key] === undefined) {
+        return;
+      }
+
+      const preset = this.presets.data[key];
+
+      if (preset !== undefined && typeof preset === type) { // eslint-disable-line valid-typeof
+        this[key] = preset;
+      }
+
+      watch(
+        () => this[key],
+        (neu) => {
+          this.presets.data[key] = neu;
+
+          try {
+            const presets = JSON.stringify(this.presets);
+
+            window.localStorage.setItem(this.presetKey, presets);
+          } catch (error) {
+            console.warn(`Preset: save presets failed, invalid presets [${ this.presetKey }]`); // eslint-disable-line no-console
+          }
+        },
+        { deep: true }
+      );
+    },
+  },
+};

package/mixins/resource-fetch-api-pagination.js

@@ -7,6 +7,7 @@ import paginationUtils from '@shell/utils/pagination-utils';
 import debounce from 'lodash/debounce';
 import { PaginationParamFilter, PaginationFilterField, PaginationArgs } from '@shell/types/store/pagination.types';
 import stevePaginationUtils from '@shell/plugins/steve/steve-pagination-utils';
+import { STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
 
 /**
  * Companion mixin used with `resource-fetch` for `ResourceList` to determine if the user needs to filter the list by a single namespace
@@ -45,6 +46,10 @@ export default {
         filters:              [],
         projectsOrNamespaces: [],
       },
+
+      paginationFromList: null,
+
+      isPaginationManualRefreshEnabled: paginationUtils.isListManualRefreshEnabled({ rootGetters: this.$store.getters }),
     };
   },
 
@@ -58,19 +63,30 @@ export default {
       }
     },
 
+    /**
+     * Primary point that handles changes from either a table or the namespace filter
+     */
     paginationChanged(event) {
-      const searchFilters = event.filter.searchQuery ? event.filter.searchFields.map((field) => new PaginationFilterField({
+      if (!event) {
+        return;
+      }
+
+      this.paginationFromList = event;
+      const {
+        page, perPage, filter, sort, descending
+      } = event;
+      const searchFilters = filter.searchQuery ? filter.searchFields.map((field) => new PaginationFilterField({
         field,
-        value: event.filter.searchQuery,
+        value: filter.searchQuery,
         exact: false,
       })) : [];
 
       const pagination = new PaginationArgs({
-        page:     event.page,
-        pageSize: event.perPage,
-        sort:     event.sort?.map((field) => ({
+        page,
+        pageSize: perPage,
+        sort:     sort?.map((field) => ({
           field,
-          asc: !event.descending
+          asc: !descending
         })),
         projectsOrNamespaces: this.requestFilters.projectsOrNamespaces,
         filters:              [
@@ -82,32 +98,6 @@ export default {
       this.debouncedSetPagination(pagination);
     },
 
-    namespaceFilterChanged(neu) {
-      if (!this.canPaginate || !this.isNamespaced) {
-        return;
-      }
-
-      const {
-        projectsOrNamespaces,
-        filters
-      } = stevePaginationUtils.createParamsFromNsFilter({
-        allNamespaces:                this.$store.getters[`${ this.currentProduct?.inStore }/all`](NAMESPACE),
-        selection:                    neu,
-        isAllNamespaces:              this.isAllNamespaces,
-        isLocalCluster:               this.$store.getters['currentCluster'].isLocal,
-        showDynamicRancherNamespaces: this.showDynamicRancherNamespaces,
-        productHidesSystemNamespaces: this.productHidesSystemNamespaces,
-      });
-
-      this.requestFilters.filters = filters;
-      this.requestFilters.projectsOrNamespaces = projectsOrNamespaces;
-
-      // Kick off a change
-      if (this.pPagination) {
-        this.debouncedSetPagination({ ...this.pPagination });
-      }
-    },
-
     /**
      * @param {PaginationArgs} neu
      * @param {PaginationArgs} old
@@ -123,6 +113,19 @@ export default {
       }
 
       return false;
+    },
+
+    calcCanPaginate() {
+      if (!this.resource) {
+        return false;
+      }
+
+      const args = {
+        id:      this.resource.id || this.resource,
+        context: this.context,
+      };
+
+      return this.$store.getters[`${ this.overrideInStore || this.inStore }/paginationEnabled`]?.(args);
     }
   },
 
@@ -181,16 +184,7 @@ export default {
         return;
       }
 
-      if (!this.resource) {
-        return false;
-      }
-
-      const args = {
-        id:      this.resource.id || this.resource,
-        context: this.context,
-      };
-
-      return this.resource && this.$store.getters[`${ this.inStore }/paginationEnabled`]?.(args);
+      return this.calcCanPaginate();
     },
 
     paginationResult() {
@@ -206,7 +200,7 @@ export default {
         return;
       }
 
-      return this.$store.getters[`${ this.inStore }/havePage`](this.resource);
+      return this.$store.getters[`${ this.overrideInStore || this.inStore }/havePage`](this.resource);
     },
 
     /**
@@ -282,10 +276,31 @@ export default {
           }
         }
 
-        this.namespaceFilterChanged(neu);
+        const {
+          projectsOrNamespaces,
+          filters
+        } = stevePaginationUtils.createParamsFromNsFilter({
+          allNamespaces:                 this.$store.getters[`${ this.currentProduct?.inStore }/all`](NAMESPACE),
+          selection:                     neu,
+          isAllNamespaces:               this.isAllNamespaces,
+          isLocalCluster:                this.$store.getters['currentCluster'].isLocal,
+          showReservedRancherNamespaces: this.showDynamicRancherNamespaces,
+          productHidesSystemNamespaces:  this.productHidesSystemNamespaces,
+        });
+
+        this.requestFilters.filters = filters;
+        this.requestFilters.projectsOrNamespaces = projectsOrNamespaces;
       }
     },
 
+    'requestFilters.filters'() {
+      this.paginationChanged(this.paginationFromList);
+    },
+
+    'requestFilters.projectsOrNamespaces'() {
+      this.paginationChanged(this.paginationFromList);
+    },
+
     /**
      * When a pagination is required and the user changes page / sort / filter, kick off a new set of API requests
      *
@@ -336,4 +351,18 @@ export default {
       });
     }
   },
+
+  async beforeUnmount() {
+    if (this.havePaginated) {
+      // of type @STEVE_WATCH_PARAMS
+      const watchArgs = {
+        type: this.resource,
+        mode: STEVE_WATCH_MODE.RESOURCE_CHANGES,
+      };
+
+      await this.$store.dispatch(`${ this.overrideInStore || this.inStore }/forgetType`, this.resource, (watchParams) => {
+        return watchParams.type === watchArgs.type && watchParams.mode === watchArgs.type.mode;
+      });
+    }
+  }
 };

package/mixins/resource-fetch.js

@@ -3,7 +3,7 @@ import { COUNT, MANAGEMENT } from '@shell/config/types';
 import { SETTING, DEFAULT_PERF_SETTING } from '@shell/config/settings';
 import ResourceFetchNamespaced from '@shell/mixins/resource-fetch-namespaced';
 import ResourceFetchApiPagination from '@shell/mixins/resource-fetch-api-pagination';
-import { cloud2harvesterhci } from '@shell/utils/router'
+import perfSettingsUtils from '@shell/utils/perf-setting.utils';
 
 // Number of pages to fetch when loading incrementally
 const PAGES = 4;
@@ -124,6 +124,9 @@ export default {
       // this is where the data assignment will trigger the update of the list view...
       if (this.init && neu) {
         await this.$fetch();
+        if (this.clearSelection) {
+          this.clearSelection();
+        }
         if (this.canPaginate && this.fetchPageSecondaryResources) {
           this.fetchPageSecondaryResources({
             canPaginate: this.canPaginate, force: true, page: this.rows, pagResult: this.paginationResult
@@ -202,15 +205,20 @@ export default {
           .finally(() => (that['paginating'] = false));
       }
 
-      let incremental = 0;
+      let incremental = null;
 
       if (this.incremental) {
         const resourceCount = this.__getCountForResources([type], this.namespaceFilter, currStore);
 
-        incremental = Math.ceil(resourceCount / PAGES);
+        incremental = {
+          quickLoadCount:        100,
+          resourcesPerIncrement: Math.ceil(resourceCount / PAGES),
+          increments:            PAGES,
+          pageByNumber:          this.$store.getters[`${ this.inStore }/paginationEnabled`]?.()
+        };
       }
 
-      const opt = {
+      const opt = { // Of type ActionFindAllArgs
         incremental,
         watch:            this.watch,
         force:            this.force,
@@ -234,7 +242,9 @@ export default {
     },
 
     __getCountForResource(resourceName, namespace, storeType) {
-      const resourceCounts = this.$store.getters[`${ storeType }/all`](COUNT)[0]?.counts[`${ resourceName }`]; // NB `rancher` store behaves differently, lacks counts but has resource
+      const currStore = storeType || this.$store.getters['currentStore']();
+
+      const resourceCounts = this.$store.getters[`${ currStore }/all`](COUNT)[0]?.counts[`${ resourceName }`]; // NB `rancher` store behaves differently, lacks counts but has resource
       const resourceCount = namespace && resourceCounts?.namespaces ? resourceCounts?.namespaces[namespace]?.count : resourceCounts?.summary?.count;
 
       return resourceCount || 0;
@@ -245,11 +255,11 @@ export default {
       this.init = true;
 
       // manual refresh settings config
-      const manualDataRefreshEnabled = this.perfConfig?.manualRefresh?.enabled;
+      const manualDataRefreshEnabled = perfSettingsUtils.manualRefreshUtils.isEnabled(this.calcCanPaginate(), this.perfConfig);
       const manualDataRefreshThreshold = parseInt(this.perfConfig?.manualRefresh?.threshold || '0', 10);
 
       // incremental loading settings config
-      const incrementalLoadingEnabled = this.perfConfig?.incrementalLoading?.enabled;
+      const incrementalLoadingEnabled = perfSettingsUtils.incrementalLoadingUtils.isEnabled(this.calcCanPaginate(), this.perfConfig);
       const incrementalLoadingThreshold = parseInt(this.perfConfig?.incrementalLoading?.threshold || '0', 10);
 
       // other vars
@@ -272,7 +282,7 @@ export default {
       if (manualDataRefreshEnabled && resourceCount >= manualDataRefreshThreshold) {
         watch = false;
         isTooManyItemsToAutoUpdate = true;
-      } else if (this.canPaginate) {
+      } else if (this.canPaginate && this.isPaginationManualRefreshEnabled) {
         isTooManyItemsToAutoUpdate = true;
       }