@rancher/shell 0.3.26 → 0.3.28

package/rancher-components/components/StringList/StringList.vue

@@ -82,6 +82,13 @@ export default Vue.extend({
         return {} as ErrorMessages;
       },
     },
+    /**
+     * Enables bulk addition and defines the delimiter to split the input string.
+     */
+    bulkAdditionDelimiter: {
+      type:    RegExp,
+      default: null,
+    }
   },
   data() {
     return {
@@ -125,13 +132,9 @@ export default Vue.extend({
   },
 
   methods: {
-    onChange(value: string) {
+    onChange(value: string, index?: number) {
       this.value = value;
-
-      const items = [
-        ...this.items,
-        this.value
-      ];
+      const items = this.addValueToItems(this.items, value, index);
 
       this.toggleError(
         'duplicate',
@@ -321,10 +324,7 @@ export default Vue.extend({
       const value = this.value?.trim();
 
       if (value) {
-        const items = [
-          ...this.items,
-          value,
-        ];
+        const items = this.addValueToItems(this.items, value);
 
         if (!hasDuplicatedStrings(items, this.caseSensitive)) {
           this.updateItems(items);
@@ -343,12 +343,8 @@ export default Vue.extend({
       const value = this.value?.trim();
 
       if (value) {
-        const items = [...this.items];
-        const index = findStringIndex(items, item, false);
-
-        if (index !== -1) {
-          items[index] = value;
-        }
+        const index = findStringIndex(this.items, item, false);
+        const items = index !== -1 ? this.addValueToItems(this.items, value, index) : this.items;
 
         if (!hasDuplicatedStrings(items, this.caseSensitive)) {
           this.updateItems(items);
@@ -360,6 +356,49 @@ export default Vue.extend({
       }
     },
 
+    /**
+     * Add a new or update an exiting item in the items list.
+     *
+     * @param items The current items list.
+     * @param value The new value to be added.
+     * @param index The list index of the item to be updated (optional).
+     * @returns Updated items list.
+     */
+    addValueToItems(items: string[], value: string, index?: number): string[] {
+      const updatedItems = [...items];
+
+      // Add new item
+      if (index === undefined) {
+        if (this.bulkAdditionDelimiter && value.search(this.bulkAdditionDelimiter) >= 0) {
+          updatedItems.push(...this.splitBulkValue(value));
+        } else {
+          updatedItems.push(value);
+        }
+      } else { // Update existing item
+        if (this.bulkAdditionDelimiter && value.search(this.bulkAdditionDelimiter) >= 0) {
+          updatedItems.splice(index, 1, ...this.splitBulkValue(value));
+        } else {
+          updatedItems[index] = value;
+        }
+      }
+
+      return updatedItems;
+    },
+
+    /**
+     * Split the value by the defined delimiter and remove empty strings.
+     *
+     * @param value The value to be split.
+     * @returns Array containing split values.
+     */
+    splitBulkValue(value: string): string[] {
+      return value
+        .split(this.bulkAdditionDelimiter)
+        .filter((item) => {
+          return item.trim().length > 0;
+        });
+    },
+
     /**
      * Remove an item from items list
      */
@@ -393,7 +432,7 @@ export default Vue.extend({
       @dblclick="onClickEmptyBody()"
     >
       <div
-        v-for="item in items"
+        v-for="(item, index) in items"
         :key="item"
         :ref="item"
         :class="{
@@ -421,7 +460,7 @@ export default Vue.extend({
           :data-testid="`item-edit-${item}`"
           class="edit-input static"
           :value="value != null ? value : item"
-          @input="onChange($event)"
+          @input="onChange($event, index)"
           @blur.prevent="updateItem(item)"
           @keydown.native.enter="updateItem(item, !errors.duplicate)"
         />

package/store/features.js

@@ -31,6 +31,7 @@ export const UNSUPPORTED_STORAGE_DRIVERS = create('unsupported-storage-drivers',
 export const FLEET = create('continuous-delivery', true);
 export const HARVESTER = create('harvester', true);
 export const HARVESTER_CONTAINER = create('harvester-baremetal-container-workload', false);
+export const FLEET_WORKSPACE_BACK = create('provisioningv2-fleet-workspace-back-population', false);
 
 // Not currently used.. no point defining ones we don't use
 // export const EMBEDDED_CLUSTER_API = create('embedded-cluster-api', true);

package/store/prefs.js

@@ -112,9 +112,6 @@ export const _RKE1 = 'rke1';
 export const _RKE2 = 'rke2';
 export const PROVISIONER = create('provisioner', _RKE2, { options: [_RKE1, _RKE2] });
 
-// Promo for Pod Security Policies (PSPs) being deprecated on kube version 1.25 on Cluster Dashboard page
-export const PSP_DEPRECATION_BANNER = create('hide-psp-deprecation-banner', false, { parseJSON });
-
 // Maximum number of clusters to show in the slide-in menu
 export const MENU_MAX_CLUSTERS = 10;
 // Prompt for confirm when scaling down node pool in GUI and save the pref

package/types/shell/index.d.ts

@@ -1765,8 +1765,6 @@ export const NODE: "node";
 export const NETWORK_POLICY: "networking.k8s.io.networkpolicy";
 export const POD: "pod";
 export const POD_DISRUPTION_BUDGET: "policy.poddisruptionbudget";
-export const PSP: "policy.podsecuritypolicy";
-export const PSPS: "policy.podsecuritypolicies";
 export const PV: "persistentvolume";
 export const PVC: "persistentvolumeclaim";
 export const RESOURCE_QUOTA: "resourcequota";
@@ -1884,8 +1882,6 @@ export namespace MANAGEMENT {
     export { GLOBAL_ROLE_1 as GLOBAL_ROLE };
     const GLOBAL_ROLE_BINDING_1: string;
     export { GLOBAL_ROLE_BINDING_1 as GLOBAL_ROLE_BINDING };
-    export const POD_SECURITY_POLICY_TEMPLATE: string;
-    export const PSP_TEMPLATE_BINDING: string;
     export const PSA: string;
     export const MANAGED_CHART: string;
     export const USER_NOTIFICATION: string;
@@ -2807,6 +2803,7 @@ export const UNSUPPORTED_STORAGE_DRIVERS: any;
 export const FLEET: any;
 export const HARVESTER: any;
 export const HARVESTER_CONTAINER: any;
+export const FLEET_WORKSPACE_BACK: any;
 export namespace getters {
     function get(state: any, getters: any, rootState: any, rootGetters: any): (name: any) => any;
 }
@@ -2868,7 +2865,6 @@ export const PLUGIN_DEVELOPER: any;
 export const _RKE1: "rke1";
 export const _RKE2: "rke2";
 export const PROVISIONER: any;
-export const PSP_DEPRECATION_BANNER: any;
 export const MENU_MAX_CLUSTERS: 10;
 export const SCALE_POOL_PROMPT: any;
 export function state(): {
@@ -3300,7 +3296,6 @@ declare namespace _default {
     export { cronSchedule };
     export { podAffinity };
     export { roleTemplateRules };
-    export { isHttps };
 }
 export default _default;
 }
@@ -3360,8 +3355,17 @@ declare module '@shell/utils/error' {
 export function stringify(err: any): any;
 export function exceptionToErrorsArray(err: any): any;
 export class ClusterNotFoundError extends Error {
+    static name: string;
     constructor(message: any);
 }
+/**
+ * An error occurred and the user should be redirected to a certain location (where this is handled)
+ */
+export class RedirectToError extends Error {
+    static name: string;
+    constructor(message: any, url: any);
+    url: any;
+}
 export class ApiError extends Error {
     constructor(res: any);
     status: any;
@@ -3444,6 +3448,9 @@ export function monitoringStatus(): {
 export function haveV2Monitoring(getters: any): boolean;
 export function haveV1Monitoring(getters: any): boolean;
 export function haveV1MonitoringWorkloads(store: any): Promise<boolean>;
+export function canViewGrafanaLink(store: any): Promise<boolean>;
+export function canViewAlertManagerLink(store: any): Promise<boolean>;
+export function canViewPrometheusLink(store: any): Promise<boolean>;
 }
 
 // @shell/utils/namespace-filter
@@ -3614,35 +3621,35 @@ export namespace KEY {
 }
 }
 
-// @shell/utils/poller-sequential
+// @shell/utils/poller
 
-declare module '@shell/utils/poller-sequential' {
-export default class PollerSequential {
+declare module '@shell/utils/poller' {
+export default class Poller {
     constructor(fn: any, pollRateMs: any, maxRetries?: number);
     fn: any;
     pollRateMs: any;
     maxRetries: number;
-    timeoutId: any;
+    intervalId: any;
     tryCount: number;
     start(): void;
     stop(): void;
-    _poll(): void;
     _intervalMethod(): Promise<void>;
 }
 }
 
-// @shell/utils/poller
+// @shell/utils/poller-sequential
 
-declare module '@shell/utils/poller' {
-export default class Poller {
+declare module '@shell/utils/poller-sequential' {
+export default class PollerSequential {
     constructor(fn: any, pollRateMs: any, maxRetries?: number);
     fn: any;
     pollRateMs: any;
     maxRetries: number;
-    intervalId: any;
+    timeoutId: any;
     tryCount: number;
     start(): void;
     stop(): void;
+    _poll(): void;
     _intervalMethod(): Promise<void>;
 }
 }
@@ -4169,7 +4176,10 @@ export function externalName(spec: any, getters: any, errors: any, validatorArgs
 // @shell/utils/validators/setting
 
 declare module '@shell/utils/validators/setting' {
-export function isHttps(value: any, getters: any, errors: any, validatorArgs: any, displayKey: any): any;
+export function isServerUrl(value: any): boolean;
+export function isHttps(value: any): any;
+export function isLocalhost(value: any): boolean;
+export function hasTrailingForwardSlash(value: any): any;
 }
 
 // @shell/utils/version
@@ -4188,7 +4198,6 @@ export function seenReleaseNotes(store: any): boolean;
 export function markSeenReleaseNotes(store: any): Promise<void>;
 export function readReleaseNotes(store: any): boolean;
 export function markReadReleaseNotes(store: any): Promise<void>;
-export function generateSupportLink(version: any): string;
 }
 
 // @shell/utils/width

package/utils/__tests__/object.test.ts

@@ -1,5 +1,5 @@
 import {
-  clone, get, getter, isEmpty, toDictionary, remove
+  clone, get, getter, isEmpty, toDictionary, remove, diff, definedKeys
 } from '@shell/utils/object';
 
 describe('fx: get', () => {
@@ -161,3 +161,69 @@ describe('fx: remove', () => {
     expect(result).toStrictEqual(expected);
   });
 });
+
+describe('fx: diff', () => {
+  it('should return an object including only the differences between two objects', () => {
+    const from = {
+      foo: 'bar',
+      baz: 'bang',
+    };
+    const to = {
+      foo:  'bar',
+      bang: 'baz'
+    };
+
+    const result = diff(from, to);
+    const expected = {
+      baz:  null,
+      bang: 'baz'
+    };
+
+    expect(result).toStrictEqual(expected);
+  });
+  it('should return an object and dot characters in object should still be respected', () => {
+    const from = {};
+    const to = { foo: { 'bar.baz': 'bang' } };
+
+    const result = diff(from, to);
+    const expected = { foo: { 'bar.baz': 'bang' } };
+
+    expect(result).toStrictEqual(expected);
+  });
+});
+
+describe('fx: definedKeys', () => {
+  it('should return an array of keys within an array', () => {
+    const obj = {
+      foo: 'bar',
+      baz: 'bang',
+    };
+
+    const result = definedKeys(obj);
+    const expected = ['"foo"', '"baz"'];
+
+    expect(result).toStrictEqual(expected);
+  });
+  it('should return an array of keys with primitive values and their full nested path', () => {
+    const obj = {
+      foo: 'bar',
+      baz: { bang: 'bop' },
+    };
+
+    const result = definedKeys(obj);
+    const expected = ['"foo"', '"baz"."bang"'];
+
+    expect(result).toStrictEqual(expected);
+  });
+  it('should return an array of keys with primitive values and their full nested path with quotation marks to escape keys with dots in them', () => {
+    const obj = {
+      foo: 'bar',
+      baz: { 'bang.bop': 'beep' },
+    };
+
+    const result = definedKeys(obj);
+    const expected = ['"foo"', '"baz"."bang.bop"'];
+
+    expect(result).toStrictEqual(expected);
+  });
+});

package/utils/__tests__/version.test.ts

@@ -1,28 +1,18 @@
-import { generateSupportLink } from '@shell/utils/version';
+import { isDevBuild } from '@shell/utils/version';
 
-describe('fx: generateSupportLink', () => {
-  it('should generate support link corresponding to the installed Rancher version', () => {
-    const version = 'v2.7.5';
-    const expectation = 'https://www.suse.com/suse-rancher/support-matrix/all-supported-versions/rancher-v2-7-5';
+describe('fx: isDevBuild', () => {
+  it.each([
+    'dev',
+    'master',
+    'head',
+    'whatever-head',
+    'whatever-rc1',
+    'whatever-alpha1',
+  ])(
+    'should exclude version type %p', (version: string) => {
+      const result = isDevBuild(version);
 
-    const result = generateSupportLink(version);
-
-    expect(result).toStrictEqual(expectation);
-  });
-
-  const latestVersionSupportURL = 'https://rancher.com/support-maintenance-terms';
-  const testCases = [
-    ['v2.7-0bcf068e1237acafd4aca01385c7c6b432e22fd7-head', latestVersionSupportURL],
-    ['v2.7.5-rc4', latestVersionSupportURL],
-    [undefined, latestVersionSupportURL],
-  ];
-
-  it.each(testCases)(
-    'should generate support link corresponding to the latest Rancher version when version is unknown or for dev build',
-    (version, expected) => {
-      const result = generateSupportLink(version);
-
-      expect(result).toBe(expected);
+      expect(result).toBe(true);
     }
   );
 });

package/utils/cluster.js

@@ -7,7 +7,7 @@ import { SETTING } from '@shell/config/settings';
 export function filterOnlyKubernetesClusters(mgmtClusters, store) {
   const openHarvesterContainerWorkload = store.getters['features/get']('harvester-baremetal-container-workload');
 
-  return mgmtClusters.filter((c) => {
+  return mgmtClusters?.filter((c) => {
     return openHarvesterContainerWorkload ? true : !isHarvesterCluster(c);
   });
 }

package/utils/custom-validators.js

@@ -8,7 +8,6 @@ import { cronSchedule } from '@shell/utils/validators/cron-schedule';
 import { podAffinity } from '@shell/utils/validators/pod-affinity';
 import { roleTemplateRules } from '@shell/utils/validators/role-template';
 import { clusterName } from '@shell/utils/validators/cluster-name';
-import { isHttps } from '@shell/utils/validators/setting';
 
 /**
 * Custom validation functions beyond normal scalr types
@@ -30,5 +29,4 @@ export default {
   cronSchedule,
   podAffinity,
   roleTemplateRules,
-  isHttps,
 };

package/utils/error.js

@@ -1,9 +1,24 @@
 import { isArray } from '@shell/utils/array';
 
 export class ClusterNotFoundError extends Error {
+  static name = 'ClusterNotFoundError'
+
   constructor(message) {
     super(message);
-    this.name = 'ClusterNotFoundError';
+    this.name = ClusterNotFoundError.name;
+  }
+}
+
+/**
+ * An error occurred and the user should be redirected to a certain location (where this is handled)
+ */
+export class RedirectToError extends Error {
+  static name = 'RedirectToError'
+
+  constructor(message, url) {
+    super(message);
+    this.url = url;
+    this.name = RedirectToError.name;
   }
 }
 

package/utils/grafana.js

@@ -63,14 +63,13 @@ export async function allDashboardsExist(store, clusterId, embeddedUrls, storeNa
 
   let monitoringVersion = '';
 
-  if (!projectId) {
+  if (!projectId && store.getters[`${ storeName }/canList`](CATALOG.APP)) {
     try {
       res = await store.dispatch(`${ storeName }/find`, {
         type: CATALOG.APP,
         id:   'cattle-monitoring-system/rancher-monitoring'
       });
     } catch (err) {
-      return false;
     }
 
     monitoringVersion = res?.currentVersion;

package/utils/monitoring.js

@@ -1,6 +1,6 @@
 // Helpers for determining if V2 or v1 Monitoring are installed
 
-import { SCHEMA, MONITORING, WORKLOAD_TYPES } from '@shell/config/types';
+import { SCHEMA, MONITORING, WORKLOAD_TYPES, ENDPOINTS } from '@shell/config/types';
 import { normalizeType } from '@shell/plugins/dashboard-store/normalize';
 import { findBy } from '@shell/utils/array';
 import { isEmpty } from '@shell/utils/object';
@@ -65,6 +65,30 @@ export async function haveV1MonitoringWorkloads(store) {
   }
 }
 
+async function hasEndpointSubsets(store, id) {
+  if (store.getters['cluster/schemaFor'](ENDPOINTS)) {
+    const endpoints = await store.dispatch('cluster/findAll', { type: ENDPOINTS }) || [];
+
+    const endpoint = endpoints.find((ep) => ep.id === id);
+
+    return endpoint && !isEmpty(endpoint) && !isEmpty(endpoint.subsets);
+  }
+
+  return false;
+}
+
+export async function canViewGrafanaLink(store) {
+  return await hasEndpointSubsets(store, `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-grafana`);
+}
+
+export async function canViewAlertManagerLink(store) {
+  return await hasEndpointSubsets(store, `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-alertmanager`);
+}
+
+export async function canViewPrometheusLink(store) {
+  return await hasEndpointSubsets(store, `${ CATTLE_MONITORING_NAMESPACE }/rancher-monitoring-prometheus`);
+}
+
 // Other ways we check for monitoring:
 
 // (1) Using counts (requires RBAC permissions)

package/utils/object.js

@@ -178,11 +178,12 @@ export function definedKeys(obj) {
     const val = obj[key];
 
     if ( Array.isArray(val) ) {
-      return key;
+      return `"${ key }"`;
     } else if ( isObject(val) ) {
-      return ( definedKeys(val) || [] ).map((subkey) => `${ key }.${ subkey }`);
+      // no need for quotes around the subkey since the recursive call will fill that in via one of the other two statements in the if block
+      return ( definedKeys(val) || [] ).map((subkey) => `"${ key }".${ subkey }`);
     } else {
-      return key;
+      return `"${ key }"`;
     }
   });
 

package/utils/sort.js

@@ -184,7 +184,7 @@ export function sortBy(ary, keys, desc) {
     keys = [keys];
   }
 
-  return ary.slice().sort((objA, objB) => {
+  return (ary || []).slice().sort((objA, objB) => {
     for ( let i = 0 ; i < keys.length ; i++ ) {
       const parsed = parseField(keys[i]);
       const a = get(objA, parsed.field);

package/utils/validators/formRules/__tests__/index.test.ts

@@ -43,21 +43,66 @@ describe('formRules', () => {
     expect(formRuleResult).toStrictEqual(expectedResult);
   });
 
-  it('"isHttps" : returns undefined when valid https url value is supplied', () => {
+  it('"https" : returns undefined when valid https url value is supplied', () => {
     const testValue = 'https://url.com';
-    const formRuleResult = formRules.isHttps('server-url')(testValue);
+    const formRuleResult = formRules.https(testValue);
 
     expect(formRuleResult).toBeUndefined();
   });
 
-  it('"isHttps" : returns correct message when http url value is supplied', () => {
+  it('"https" : returns correct message when http url value is supplied', () => {
     const testValue = 'http://url.com';
-    const formRuleResult = formRules.isHttps('server-url')(testValue);
+    const formRuleResult = formRules.https(testValue);
     const expectedResult = JSON.stringify({ message: 'validation.setting.serverUrl.https' });
 
     expect(formRuleResult).toStrictEqual(expectedResult);
   });
 
+  describe('localhost', () => {
+    const message = JSON.stringify({ message: 'validation.setting.serverUrl.localhost' });
+    const testCases = [
+      ['http://LOCALhosT:8005', message],
+      ['http://localhost:8005', message],
+      ['https://localhost:8005', message],
+      ['localhost', message],
+      ['http://127.0.0.1', message],
+      ['https://127.0.0.1', message],
+      ['127.0.0.1', message],
+      ['https://test.com', undefined],
+      ['https://test.com/localhost', undefined],
+      [undefined, undefined]
+    ];
+
+    it.each(testCases)(
+      'should return undefined or correct message based on the provided url',
+      (url, expected) => {
+        const formRuleResult = formRules.localhost(url);
+
+        expect(formRuleResult).toStrictEqual(expected);
+      }
+    );
+  });
+
+  describe('trailingForwardSlash', () => {
+    const message = JSON.stringify({ message: 'validation.setting.serverUrl.trailingForwardSlash' });
+    const testCases = [
+      ['https://test.com', undefined],
+      ['https://test.com/', message],
+      ['https://', undefined],
+      ['/', undefined],
+      [undefined, undefined]
+    ];
+
+    it.each(testCases)(
+      'should return undefined or correct message based on the provided url',
+      (url, expected) => {
+        const formRuleResult = formRules.trailingForwardSlash(url);
+
+        expect(formRuleResult).toStrictEqual(expected);
+      }
+    );
+  });
+
   it('"interval" : returns undefined when valid hour interval value is supplied', () => {
     const testValue = '5h';
     const formRuleResult = formRules.interval(testValue);

package/utils/validators/formRules/index.ts

@@ -2,9 +2,11 @@ import { RBAC } from '@shell/config/types';
 import { HCI } from '@shell/config/labels-annotations';
 import isEmpty from 'lodash/isEmpty';
 import has from 'lodash/has';
+import isUrl from 'is-url';
 // import uniq from 'lodash/uniq';
 import cronstrue from 'cronstrue';
 import { Translation } from '@shell/types/t';
+import { isHttps, isLocalhost, hasTrailingForwardSlash } from '@shell/utils/validators/setting';
 
 // import uniq from 'lodash/uniq';
 export type Validator<T = undefined | string> = (val: any, arg?: any) => T;
@@ -34,10 +36,6 @@ export class Port {
   }
 }
 
-const httpsKeys = [
-  'server-url'
-];
-
 const runValidators = (val: any, validators: Validator[]) => {
   for (const validator of validators) {
     const message = validator(val);
@@ -139,11 +137,13 @@ export default function(t: Translation, { key = 'Value' }: ValidationOptions): {
     }
   };
 
-  const isHttps: ValidatorFactory = (key: string) => {
-    const isHttps: Validator = (val: string) => httpsKeys.includes(key) && !val.toLowerCase().startsWith('https://') ? t('validation.setting.serverUrl.https') : undefined;
+  const https: Validator = (val: string) => val && !isHttps(val) ? t('validation.setting.serverUrl.https') : undefined;
 
-    return isHttps;
-  };
+  const localhost: Validator = (val: string) => isLocalhost(val) ? t('validation.setting.serverUrl.localhost') : undefined;
+
+  const trailingForwardSlash: Validator = (val: string) => hasTrailingForwardSlash(val) ? t('validation.setting.serverUrl.trailingForwardSlash') : undefined;
+
+  const url: Validator = (val: string) => val && !isUrl(val) ? t('validation.setting.serverUrl.url') : undefined;
 
   const interval: Validator = (val: string) => !/^\d+[hms]$/.test(val) ? t('validation.monitoring.route.interval', { key }) : undefined;
 
@@ -382,7 +382,7 @@ export default function(t: Translation, { key = 'Value' }: ValidationOptions): {
       if (val.some((rule: any) => isEmpty(rule.apiGroups))) {
         return t('validation.roleTemplate.roleTemplateRules.missingApiGroup');
       }
-    } else if (val.some((rule: any) => isEmpty(rule.resources) && isEmpty(rule.nonResourceURLs) && isEmpty(rule.apiGroups))) {
+    } else if (val.some((rule: any) => isEmpty(rule.resources) && isEmpty(rule.nonResourceURLs))) {
       return t('validation.roleTemplate.roleTemplateRules.missingOneResource');
     }
 
@@ -475,7 +475,10 @@ export default function(t: Translation, { key = 'Value' }: ValidationOptions): {
     hostname,
     imageUrl,
     interval,
-    isHttps,
+    https,
+    localhost,
+    trailingForwardSlash,
+    url,
     matching,
     maxLength,
     maxValue,

package/utils/validators/role-template.js

@@ -21,7 +21,7 @@ export function roleTemplateRules(rules = [], getters, errors, validatorArgs = [
     errors.push(getters['i18n/t']('validation.roleTemplate.roleTemplateRules.noResourceAndNonResource'));
   }
 
-  if (rules.some((rule) => isEmpty(rule.resources) && isEmpty(rule.nonResourceURLs) && isEmpty(rule.apiGroups))) {
+  if (rules.some((rule) => isEmpty(rule.resources) && isEmpty(rule.nonResourceURLs))) {
     errors.push(getters['i18n/t']('validation.roleTemplate.roleTemplateRules.missingOneResource'));
   }
 }