@rancher/shell 0.1.0

package/models/management.cattle.io.project.js

@@ -0,0 +1,135 @@
+import { DEFAULT_PROJECT, SYSTEM_PROJECT } from '@shell/config/labels-annotations';
+import { MANAGEMENT, NAMESPACE, NORMAN } from '@shell/config/types';
+import HybridModel from '@shell/plugins/steve/hybrid-class';
+
+function clearResourceQuotas(val, type) {
+  if (val[type]?.limit && Object.keys(val[type].limit).length) {
+    Object.keys(val[type].limit).forEach((key) => {
+      if (!val[type].limit[key]) {
+        delete val[type].limit[key];
+      }
+    });
+  }
+
+  if ( val[type]?.limit && !Object.keys(val[type].limit).length ) {
+    delete val[type].limit;
+  }
+
+  if ( val[type] && !Object.keys(val[type]).length ) {
+    delete val[type];
+  }
+
+  return val[type];
+}
+
+export default class Project extends HybridModel {
+  get isSystem() {
+    return this.metadata?.labels?.[SYSTEM_PROJECT] === 'true';
+  }
+
+  get isDefault() {
+    return this.metadata?.labels?.[DEFAULT_PROJECT] === 'true';
+  }
+
+  get namespaces() {
+    // I don't know how you'd end up with a project outside of rancher, but just in case...
+    if ( !this.$rootGetters['isRancher'] ) {
+      return [];
+    }
+
+    const inStore = this.$rootGetters['currentProduct'].inStore;
+
+    const all = this.$rootGetters[`${ inStore }/all`](NAMESPACE);
+
+    return all.filter((ns) => {
+      return ns.projectId === this.metadata.name;
+    });
+  }
+
+  get listLocation() {
+    return { name: 'c-cluster-product-projectsnamespaces' };
+  }
+
+  get parentLocationOverride() {
+    return this.listLocation;
+  }
+
+  async save() {
+    const norman = await this.norman;
+
+    const newValue = await norman.save();
+
+    newValue.doAction('setpodsecuritypolicytemplate', { podSecurityPolicyTemplateId: this.spec.podSecurityPolicyTemplateId || null });
+
+    await this.$dispatch('management/findAll', { type: MANAGEMENT.PROJECT, opt: { force: true } }, { root: true });
+
+    return newValue;
+  }
+
+  async remove() {
+    const norman = await this.norman;
+
+    await norman.remove(...arguments);
+    this.$dispatch('management/remove', this, { root: true });
+  }
+
+  get norman() {
+    return this.id ? this.normanEditProject : this.normanNewProject;
+  }
+
+  get normanNewProject() {
+    return (async() => {
+      const normanProject = await this.$dispatch('rancher/create', {
+        type:                          NORMAN.PROJECT,
+        name:                          this.spec.displayName,
+        description:                   this.spec.description,
+        annotations:                   this.metadata.annotations,
+        labels:                        this.metadata.labels,
+        clusterId:                     this.$rootGetters['currentCluster'].id,
+        creatorId:                     this.$rootGetters['auth/principalId'],
+        containerDefaultResourceLimit: this.spec.containerDefaultResourceLimit,
+        namespaceDefaultResourceQuota: clearResourceQuotas(JSON.parse(JSON.stringify(this.spec)), 'namespaceDefaultResourceQuota'),
+        resourceQuota:                 clearResourceQuotas(JSON.parse(JSON.stringify(this.spec)), 'resourceQuota'),
+      }, { root: true });
+
+      // The backend seemingly required both labels/annotation and metadata.labels/annotations or it doesn't save the labels and annotations
+      normanProject.setAnnotations(this.metadata.annotations);
+      normanProject.setLabels(this.metadata.labels);
+
+      return normanProject;
+    })();
+  }
+
+  get normanEditProject() {
+    return (async() => {
+      const normanProject = await this.$dispatch('rancher/find', {
+        type:       NORMAN.PROJECT,
+        id:         this.id.replace('/', ':'),
+      }, { root: true });
+
+      normanProject.setAnnotations(this.metadata.annotations);
+      normanProject.setLabels(this.metadata.labels);
+      normanProject.description = this.spec.description;
+      normanProject.containerDefaultResourceLimit = this.spec.containerDefaultResourceLimit;
+      normanProject.namespaceDefaultResourceQuota = clearResourceQuotas(JSON.parse(JSON.stringify(this.spec)), 'namespaceDefaultResourceQuota');
+      normanProject.resourceQuota = clearResourceQuotas(JSON.parse(JSON.stringify(this.spec)), 'resourceQuota');
+
+      return normanProject;
+    })();
+  }
+
+  // users with permissions for projectroletemplatebindings should be able to manage members on projects
+  get canUpdate() {
+    return super.canUpdate || this.canUpdateProjectBindings;
+  }
+
+  get canUpdateProjectBindings() {
+    const schema = this.$rootGetters[`rancher/schemaFor`](NORMAN.PROJECT_ROLE_TEMPLATE_BINDING);
+
+    return schema?.collectionMethods.includes('POST');
+  }
+
+  get canEditYaml() {
+    return this.schema?.resourceMethods?.find(x => x === 'blocked-PUT') ? false : super.canUpdate;
+  }
+}

package/models/management.cattle.io.projectroletemplatebinding.js

@@ -0,0 +1,150 @@
+import { CREATOR_ID } from '@shell/config/labels-annotations';
+import { MANAGEMENT, NORMAN } from '@shell/config/types';
+import HybridModel from '@shell/plugins/steve/hybrid-class';
+
+export default class PRTB extends HybridModel {
+  get canCustomEdit() {
+    return false;
+  }
+
+  get canYaml() {
+    return false;
+  }
+
+  get canClone() {
+    return false;
+  }
+
+  get user() {
+    return this.$rootGetters['management/byId'](MANAGEMENT.USER, this.userName);
+  }
+
+  get principal() {
+    const principalId = this.principalId.replace(/\//g, '%2F');
+
+    return this.$dispatch('rancher/find', {
+      type: NORMAN.PRINCIPAL,
+      id:   this.principalId,
+      opt:  { url: `/v3/principals/${ principalId }` }
+    }, { root: true });
+  }
+
+  get principalId() {
+    // We've either set it ourselves or it's comes from native properties
+    return this.principalName || this.userPrincipalName || this.groupPrincipalName;
+  }
+
+  get nameDisplay() {
+    return this.user?.nameDisplay;
+  }
+
+  get projectId() {
+    // projectName is in format `local:p-v679w`. project id's are in format `local/p-v679w`,
+    return this.projectName?.replace(':', '/');
+  }
+
+  get clusterId() {
+    // projectName is in format `local:p-v679w`,
+    return this.projectName.substring(0, this.projectName.lastIndexOf(':'));
+  }
+
+  get project() {
+    return this.$rootGetters['management/byId'](MANAGEMENT.PROJECT, this.projectId);
+  }
+
+  get cluster() {
+    return this.$rootGetters['management/byId'](MANAGEMENT.CLUSTER, this.clusterId);
+  }
+
+  get projectDisplayName() {
+    return this.project ? this.project.nameDisplay : this.projectName;
+  }
+
+  get clusterDisplayName() {
+    return this.cluster ? this.cluster.nameDisplay : this.clusterId;
+  }
+
+  get userAvatar() {
+    return {
+      nameDisplay: this.nameDisplay,
+      userName:    this.user.username,
+      avatarSrc:   this.user.avatarSrc
+    };
+  }
+
+  get projectDetailLocation() {
+    if (this.project) {
+      return this.project.detailLocation;
+    }
+
+    const name = `c-cluster-product-resource-id`;
+
+    const params = {
+      resource:  MANAGEMENT.PROJECT,
+      id:        this.projectId,
+      product:   'explorer',
+    };
+
+    return { name, params };
+  }
+
+  get clusterDetailLocation() {
+    if (this.cluster) {
+      return this.cluster.detailLocation;
+    }
+
+    const name = `c-cluster-product-resource-id`;
+
+    const params = {
+      resource:  MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING,
+      id:        this.clusterName,
+      product:   'explorer',
+    };
+
+    return { name, params };
+  }
+
+  get roleTemplate() {
+    return this.$rootGetters['management/byId'](MANAGEMENT.ROLE_TEMPLATE, this.roleTemplateName);
+  }
+
+  get roleDisplay() {
+    return this.roleTemplate.nameDisplay;
+  }
+
+  get listLocation() {
+    return { name: 'c-cluster-explorer-project-members' };
+  }
+
+  get isSystem() {
+    return !this.metadata.annotations[CREATOR_ID];
+  }
+
+  get norman() {
+    return (async() => {
+      const principal = await this.principal;
+      const principalProperty = principal.principalType === 'group' ? 'groupPrincipalId' : 'userPrincipalId';
+
+      return this.$dispatch(`rancher/create`, {
+        type:                  NORMAN.PROJECT_ROLE_TEMPLATE_BINDING,
+        roleTemplateId:        this.roleTemplateName,
+        [principalProperty]:   principal.id,
+        projectId:             this.projectName,
+        projectRoleTemplateId: '',
+        id:                    this.id?.replace('/', ':')
+      }, { root: true });
+    })();
+  }
+
+  async save() {
+    const norman = await this.norman;
+
+    return norman.save();
+  }
+
+  async remove() {
+    const norman = await this.norman;
+
+    await norman.remove({ url: `/v3/projectRoleTemplateBindings/${ norman.id }` });
+  }
+}

package/models/management.cattle.io.roletemplate.js

@@ -0,0 +1,173 @@
+import Vue from 'vue';
+import { get } from '@shell/utils/object';
+import { DESCRIPTION } from '@shell/config/labels-annotations';
+import { NORMAN } from '@shell/config/types';
+import SteveModel from '@shell/plugins/steve/steve-class';
+import Role from './rbac.authorization.k8s.io.role';
+
+export const CATTLE_API_GROUP = '.cattle.io';
+
+export const SUBTYPE_MAPPING = {
+  GLOBAL:    {
+    key:            'GLOBAL',
+    type:           'management.cattle.io.globalrole',
+    defaultKey:     'newUserDefault',
+    id:             'GLOBAL',
+    labelKey:          'rbac.roletemplate.subtypes.GLOBAL.label',
+  },
+  CLUSTER:   {
+    key:            'CLUSTER',
+    type:           'management.cattle.io.roletemplate',
+    context:        'cluster',
+    defaultKey:     'clusterCreatorDefault',
+    id:             'CLUSTER',
+    labelKey:          'rbac.roletemplate.subtypes.CLUSTER.label',
+  },
+  NAMESPACE: {
+    key:            'NAMESPACE',
+    type:           'management.cattle.io.roletemplate',
+    context:        'project',
+    defaultKey:     'projectCreatorDefault',
+    id:             'NAMESPACE',
+    labelKey:          'rbac.roletemplate.subtypes.NAMESPACE.label',
+  },
+  RBAC_ROLE: {
+    key:            'RBAC_ROLE',
+    type:           'rbac.authorization.k8s.io.role',
+    id:             'RBAC_ROLE',
+    labelKey:          'rbac.roletemplate.subtypes.RBAC_ROLE.label',
+  },
+  RBAC_CLUSTER_ROLE: {
+    key:            'RBAC_CLUSTER_ROLE',
+    type:           'rbac.authorization.k8s.io.clusterrole',
+    id:             'RBAC_CLUSTER_ROLE',
+    labelKey:          'rbac.roletemplate.subtypes.RBAC_CLUSTER_ROLE.label',
+  }
+};
+
+export const VERBS = [
+  'create',
+  'delete',
+  'get',
+  'list',
+  'patch',
+  'update',
+  'watch',
+];
+
+export default class RoleTemplate extends SteveModel {
+  get customValidationRules() {
+    return Role.customValidationRules();
+  }
+
+  get details() {
+    const out = this._details;
+
+    out.unshift({
+      label:         this.t('resourceDetail.detailTop.name'),
+      content:       get(this, 'name')
+    },
+    // API returns a blank description property, this overrides our own link to the description
+    {
+      label:         this.t('resourceDetail.detailTop.description'),
+      content:       this.metadata?.annotations?.[DESCRIPTION]
+    });
+
+    return out;
+  }
+
+  get state() {
+    return this.locked ? 'locked' : this.metadata?.state?.name || 'unknown';
+  }
+
+  get subtype() {
+    if (this._subtype) {
+      return this._subtype;
+    }
+
+    if (this.type === SUBTYPE_MAPPING.CLUSTER.type && this.context === SUBTYPE_MAPPING.CLUSTER.context) {
+      return SUBTYPE_MAPPING.CLUSTER.key;
+    }
+
+    if (this.type === SUBTYPE_MAPPING.NAMESPACE.type && this.context === SUBTYPE_MAPPING.NAMESPACE.context) {
+      return SUBTYPE_MAPPING.NAMESPACE.key;
+    }
+
+    return null;
+  }
+
+  updateSubtype(subtype) {
+    Vue.set(this, '_subtype', subtype);
+    this.context = SUBTYPE_MAPPING[subtype].context;
+  }
+
+  get default() {
+    const defaultKey = SUBTYPE_MAPPING[this.subtype]?.defaultKey;
+
+    return !!this[defaultKey];
+  }
+
+  updateDefault(value) {
+    const defaultKey = SUBTYPE_MAPPING[this.subtype].defaultKey;
+
+    Vue.set(this, defaultKey, value);
+  }
+
+  get listLocation() {
+    return {
+      name: `c-cluster-auth-roles`,
+      hash: `#${ this.subtype }`
+    };
+  }
+
+  get detailLocation() {
+    return {
+      ...this._detailLocation,
+      name: `c-cluster-auth-roles-resource-id`,
+    };
+  }
+
+  get doneOverride() {
+    return this.listLocation;
+  }
+
+  get parentLocationOverride() {
+    return this.listLocation;
+  }
+
+  get basicNorman() {
+    if (this.id) {
+      return this.$dispatch(`rancher/find`, { id: this.id, type: NORMAN.ROLE_TEMPLATE }, { root: true });
+    }
+
+    return this.$dispatch(`rancher/create`, { type: NORMAN.ROLE_TEMPLATE, name: this.displayName }, { root: true });
+  }
+
+  get norman() {
+    return (async() => {
+      const norman = await this.basicNorman;
+
+      norman.rules = this.rules;
+      norman.locked = this.locked;
+      norman.clusterCreatorDefault = this.clusterCreatorDefault || false;
+      norman.projectCreatorDefault = this.projectCreatorDefault || false;
+      norman.context = this.context;
+      norman.description = this.description;
+      norman.roleTemplateIds = this.roleTemplateNames;
+
+      return norman;
+    })();
+  }
+
+  async save() {
+    const norman = await this.norman;
+
+    return norman.save();
+  }
+
+  async remove() {
+    const norman = await this.norman;
+
+    await norman.remove();
+  }
+}

package/models/management.cattle.io.setting.js

@@ -0,0 +1,42 @@
+import { ALLOWED_SETTINGS } from '@shell/config/settings';
+import HybridModel from '@shell/plugins/steve/hybrid-class';
+
+export default class Setting extends HybridModel {
+  get fromEnv() {
+    return (this.source || '').toLowerCase() === 'env';
+  }
+
+  get _availableActions() {
+    const toFilter = ['cloneYaml', 'download', 'goToEditYaml', 'goToViewYaml', 'goToViewConfig'];
+    const settingMetadata = ALLOWED_SETTINGS[this.id];
+    let out = super._availableActions;
+
+    // Some settings are not editable
+    if ( settingMetadata?.readOnly || this.fromEnv ) {
+      toFilter.push('goToEdit');
+    }
+
+    out = out.filter((action) => {
+      return (!toFilter.includes(action.action));
+    });
+
+    // Change the label on the first action (edit)
+    const editAction = out.find(action => action.action === 'goToEdit');
+
+    if (editAction) {
+      editAction.label = this.t('advancedSettings.edit.label');
+    }
+
+    return out;
+  }
+
+  get customValidationRules() {
+    return [
+      {
+        path:           'value',
+        translationKey: 'setting.serverUrl.https',
+        validators:     [`isHttps:${ this.metadata.name }`]
+      },
+    ];
+  }
+}

package/models/management.cattle.io.user.js

@@ -0,0 +1,201 @@
+import { NORMAN } from '@shell/config/types';
+import HybridModel from '@shell/plugins/steve/hybrid-class';
+
+export default class User extends HybridModel {
+  get isSystem() {
+    for ( const p of this.principalIds || [] ) {
+      if ( p.startsWith('system://') ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  get isCurrentUser() {
+    const currentPrincipal = this.$rootGetters['auth/principalId'];
+
+    return !!(this.principalIds || []).find(p => p === currentPrincipal);
+  }
+
+  get principals() {
+    return this.principalIds
+      .map(id => this.$rootGetters['rancher/byId'](NORMAN.PRINCIPAL, id))
+      .filter(p => p);
+  }
+
+  get nameDisplay() {
+    return this.displayName || this.username || this.id;
+  }
+
+  get labelForSelect() {
+    const name = this.nameDisplay;
+    const id = this.id;
+
+    if ( name === id ) {
+      return id;
+    } else {
+      return `${ name } (${ id })`;
+    }
+  }
+
+  get provider() {
+    const principals = this.principalIds || [];
+    let isSystem = false;
+    let isLocal = true;
+    let provider = '';
+
+    for ( const p of principals ) {
+      const idx = p.indexOf(':');
+      const driver = p.substr(0, idx).toLowerCase().split('_')[0];
+
+      if ( driver === 'system' ) {
+        isSystem = true;
+      } else if ( driver === 'local' ) {
+        // Do nothing, defaults to local
+      } else {
+        isLocal = false;
+
+        if ( provider ) {
+          provider = 'multiple';
+        } else {
+          provider = driver;
+        }
+      }
+    }
+
+    let key;
+
+    if ( isSystem ) {
+      key = 'system';
+    } else if ( isLocal ) {
+      key = 'local';
+    } else {
+      key = provider;
+    }
+
+    return key;
+  }
+
+  get providerDisplay() {
+    return this.$rootGetters['i18n/withFallback'](`model.authConfig.provider."${ this.provider }"`, null, this.provider);
+  }
+
+  get state() {
+    if ( this.enabled === false ) {
+      return 'inactive';
+    }
+
+    return this.metadata?.state?.name || 'unknown';
+  }
+
+  async save(opt) {
+    const clone = await this.$dispatch('clone', { resource: this });
+
+    // Remove local properties
+    delete clone.canRefreshAccess;
+
+    return clone._save(opt);
+  }
+
+  async setEnabled(enabled) {
+    const clone = await this.$dispatch('rancher/clone', { resource: this.norman }, { root: true });
+
+    clone.enabled = enabled;
+    await clone.save();
+  }
+
+  async activate() {
+    await this.setEnabled(true);
+  }
+
+  async activateBulk(items) {
+    await Promise.all(items.map(item => item.setEnabled(true)));
+  }
+
+  async deactivate() {
+    await this.setEnabled(false);
+  }
+
+  async deactivateBulk(items) {
+    await Promise.all(items.map(item => item.setEnabled(false)));
+  }
+
+  async refreshGroupMembership() {
+    const user = await this.$dispatch('rancher/find', {
+      type:       NORMAN.USER,
+      id:   this.id,
+    }, { root: true });
+
+    await user.doAction('refreshauthprovideraccess');
+  }
+
+  canActivate(state) {
+    const stateOk = state ? this.state === 'inactive' : this.state === 'active';
+    const permissionOk = this.hasLink('update'); // Not canUpdate, only gate on api not whether editable pages should be visible
+
+    return stateOk && permissionOk && !this.isCurrentUser;
+  }
+
+  get _availableActions() {
+    return [
+      {
+        action:     'activate',
+        label:      this.t('action.activate'),
+        icon:       'icon icon-play',
+        bulkable:   true,
+        bulkAction: 'activateBulk',
+        enabled:    this.canActivate(true),
+        weight:     2
+      },
+      {
+        action:     'deactivate',
+        label:      this.t('action.deactivate'),
+        icon:       'icon icon-pause',
+        bulkable:   true,
+        bulkAction: 'deactivateBulk',
+        enabled:    this.canActivate(false),
+        weight:     1
+      },
+      {
+        action:     'refreshGroupMembership',
+        label:      this.t('authGroups.actions.refresh'),
+        icon:       'icon icon-refresh',
+        enabled: this.canRefreshAccess
+      },
+      { divider: true },
+      ...super._availableActions,
+    ];
+  }
+
+  get details() {
+    return [
+      {
+        label:     this.t('user.detail.username'),
+        formatter: 'CopyToClipboard',
+        content:   this.username
+      },
+      ...this._details
+    ];
+  }
+
+  get confirmRemove() {
+    return true;
+  }
+
+  get norman() {
+    return this.$rootGetters['rancher/byId'](NORMAN.USER, this.id);
+  }
+
+  get canDelete() {
+    return this.norman?.hasLink('remove') && !this.isCurrentUser;
+  }
+
+  get canUpdate() {
+    return this.norman?.hasLink('update');
+  }
+
+  remove() {
+    return this.norman?.remove();
+  }
+}