OpenAPI CRUD views

ui/app/adapters/generated-item-list.js

@@ -0,0 +1,35 @@
+import { assign } from '@ember/polyfills';
+import ApplicationAdapter from './application';
+
+export default ApplicationAdapter.extend({
+  namespace: 'v1',
+  urlForItem() {},
+  optionsForQuery(id) {
+    let data = {};
+    if (!id) {
+      data['list'] = true;
+    }
+    return { data };
+  },
+
+  fetchByQuery(store, query) {
+    const { id, method, type } = query;
+    return this.ajax(this.urlForItem(method, id, type), 'GET', this.optionsForQuery(id)).then(resp => {
+      const data = {
+        id,
+        name: id,
+        method,
+      };
+
+      return assign({}, resp, data);
+    });
+  },
+
+  query(store, type, query) {
+    return this.fetchByQuery(store, query);
+  },
+
+  queryRecord(store, type, query) {
+    return this.fetchByQuery(store, query);
+  },
+});

ui/app/components/generated-item.js

@@ -0,0 +1,52 @@
+import { inject as service } from '@ember/service';
+import Component from '@ember/component';
+import { computed } from '@ember/object';
+import { task } from 'ember-concurrency';
+import DS from 'ember-data';
+
+/**
+ * @module GeneratedItem
+ * The `GeneratedItem` is the form to configure generated items related to mounts (e.g. groups, roles, users)
+ *
+ * @example
+ * ```js
+ * <GeneratedItem @model={{model}} @mode={{mode}} @itemType={{itemType/>
+ * ```
+ *
+ * @property model=null {DS.Model} - The corresponding item model that is being configured.
+ * @property mode {String} - which config mode to use. either `show`, `edit`, or `create`
+ * @property itemType {String} - the type of item displayed
+ *
+ */
+
+export default Component.extend({
+  model: null,
+  itemType: null,
+  flashMessages: service(),
+  router: service(),
+  props: computed(function() {
+    return this.model.serialize();
+  }),
+  saveModel: task(function*() {
+    try {
+      yield this.model.save();
+    } catch (err) {
+      // AdapterErrors are handled by the error-message component
+      // in the form
+      if (err instanceof DS.AdapterError === false) {
+        throw err;
+      }
+      return;
+    }
+    this.router.transitionTo('vault.cluster.access.method.item.list').followRedirects();
+    this.flashMessages.success(`The ${this.itemType} configuration was saved successfully.`);
+  }).withTestWaiter(),
+  actions: {
+    deleteItem() {
+      this.model.destroyRecord().then(() => {
+        this.router.transitionTo('vault.cluster.access.method.item.list').followRedirects();
+        this.flashMessages.success(`${this.model.id} ${this.itemType} was deleted successfully.`);
+      });
+    },
+  },
+});

ui/app/components/section-tabs.js

@@ -2,13 +2,12 @@ import Component from '@ember/component';
 
 const SectionTabs = Component.extend({
   tagName: '',
-
   model: null,
   tabType: 'authSettings',
 });
 
 SectionTabs.reopenClass({
-  positionalParams: ['model', 'tabType'],
+  positionalParams: ['model', 'tabType', 'paths'],
 });
 
 export default SectionTabs;

ui/app/controllers/vault/cluster/access/method/item/list.js

@@ -0,0 +1,4 @@
+import Controller from '@ember/controller';
+import ListController from 'vault/mixins/list-controller';
+
+export default Controller.extend(ListController, {});

ui/app/helpers/tabs-for-auth-section.js

@@ -1,4 +1,6 @@
 import { helper as buildHelper } from '@ember/component/helper';
+import { pluralize } from 'ember-inflector';
+import { capitalize } from '@ember/string';
 
 const TABS_FOR_SETTINGS = {
   aws: [
@@ -73,19 +75,28 @@ const TABS_FOR_SETTINGS = {
 
 const TABS_FOR_SHOW = {};
 
-export function tabsForAuthSection([methodType, sectionType = 'authSettings']) {
+export function tabsForAuthSection([model, sectionType = 'authSettings', paths]) {
   let tabs;
-
   if (sectionType === 'authSettings') {
-    tabs = (TABS_FOR_SETTINGS[methodType] || []).slice();
+    tabs = (TABS_FOR_SETTINGS[model.type] || []).slice();
     tabs.push({
       label: 'Method Options',
       routeParams: ['vault.cluster.settings.auth.configure.section', 'options'],
     });
     return tabs;
   }
 
-  tabs = (TABS_FOR_SHOW[methodType] || []).slice();
+  if (paths) {
+    tabs = paths.map(path => {
+      let itemName = path.slice(1); //get rid of leading slash
+      return {
+        label: capitalize(pluralize(itemName)),
+        routeParams: ['vault.cluster.access.method.item.list', itemName],
+      };
+    });
+  } else {
+    tabs = (TABS_FOR_SHOW[model.type] || []).slice();
+  }
   tabs.push({
     label: 'Configuration',
     routeParams: ['vault.cluster.access.method.section', 'configuration'],

ui/app/router.js

@@ -39,6 +39,12 @@ Router.map(function() {
         this.route('methods', { path: '/' });
         this.route('method', { path: '/:path' }, function() {
           this.route('index', { path: '/' });
+          this.route('item', { path: '/item/:item_type' }, function() {
+            this.route('list', { path: '/' });
+            this.route('create');
+            this.route('edit', { path: '/edit/:item_id' });
+            this.route('show', { path: '/:item_id' });
+          });
           this.route('section', { path: '/:section_name' });
         });
         this.route('leases', function() {

ui/app/routes/vault/cluster/access/method.js

@@ -1,9 +1,12 @@
 import { set } from '@ember/object';
 import Route from '@ember/routing/route';
 import DS from 'ember-data';
+import { inject as service } from '@ember/service';
 
 export default Route.extend({
+  pathHelp: service('path-help'),
   model(params) {
+    // eslint-disable-line rule
     const { path } = params;
     return this.store.findAll('auth-method').then(modelArray => {
       const model = modelArray.findBy('id', path);
@@ -12,6 +15,12 @@ export default Route.extend({
         set(error, 'httpStatus', 404);
         throw error;
       }
+      if (model.type === 'ldap') {
+        return this.pathHelp.getPaths(model.apiPath, path).then(paths => {
+          model.set('paths', paths);
+          return model;
+        });
+      }
       return model;
     });
   },

ui/app/routes/vault/cluster/access/method/item.js

@@ -0,0 +1,30 @@
+import { inject as service } from '@ember/service';
+import Route from '@ember/routing/route';
+import { getOwner } from '@ember/application';
+import { singularize } from 'ember-inflector';
+
+export default Route.extend({
+  wizard: service(),
+  pathHelp: service('path-help'),
+
+  beforeModel() {
+    const { item_type: itemType } = this.paramsFor(this.routeName);
+    const { path: method } = this.paramsFor('vault.cluster.access.method');
+    let methodModel = this.modelFor('vault.cluster.access.method');
+    let { apiPath, type } = methodModel;
+    let modelType = `generated-${singularize(itemType)}-${type}`;
+    return this.pathHelp.getNewModel(modelType, getOwner(this), method, apiPath, itemType);
+  },
+
+  setupController(controller) {
+    this._super(...arguments);
+    const { item_type: itemType } = this.paramsFor(this.routeName);
+    const { path } = this.paramsFor('vault.cluster.access.method');
+    const { apiPath } = this.modelFor('vault.cluster.access.method');
+    controller.set('itemType', itemType);
+    controller.set('method', path);
+    this.pathHelp.getPaths(apiPath, path, itemType).then(paths => {
+      controller.set('paths', Array.from(paths.list, pathInfo => pathInfo.path));
+    });
+  },
+});

ui/app/routes/vault/cluster/access/method/item/create.js

@@ -0,0 +1,28 @@
+import Route from '@ember/routing/route';
+import UnloadModelRoute from 'vault/mixins/unload-model-route';
+import UnsavedModelRoute from 'vault/mixins/unsaved-model-route';
+import { singularize } from 'ember-inflector';
+
+export default Route.extend(UnloadModelRoute, UnsavedModelRoute, {
+  model() {
+    const { item_type: itemType } = this.paramsFor('vault.cluster.access.method.item');
+    const methodModel = this.modelFor('vault.cluster.access.method');
+    const { type } = methodModel;
+    const { path: method } = this.paramsFor('vault.cluster.access.method');
+    const modelType = `generated-${singularize(itemType)}-${type}`;
+    return this.store.createRecord(modelType, {
+      itemType,
+      method,
+      adapterOptions: { path: `${method}/${itemType}` },
+    });
+  },
+
+  setupController(controller) {
+    this._super(...arguments);
+    const { item_type: itemType } = this.paramsFor('vault.cluster.access.method.item');
+    const { path: method } = this.paramsFor('vault.cluster.access.method');
+    controller.set('itemType', singularize(itemType));
+    controller.set('mode', 'create');
+    controller.set('method', method);
+  },
+});

ui/app/routes/vault/cluster/access/method/item/edit.js

@@ -0,0 +1,25 @@
+import Route from '@ember/routing/route';
+import UnloadModelRoute from 'vault/mixins/unload-model-route';
+import UnsavedModelRoute from 'vault/mixins/unsaved-model-route';
+import { singularize } from 'ember-inflector';
+
+export default Route.extend(UnloadModelRoute, UnsavedModelRoute, {
+  model(params) {
+    const methodModel = this.modelFor('vault.cluster.access.method');
+    const { type } = methodModel;
+    const { item_type: itemType } = this.paramsFor('vault.cluster.access.method.item');
+    let modelType = `generated-${singularize(itemType)}-${type}`;
+    return this.store.findRecord(modelType, params.item_id);
+  },
+
+  setupController(controller) {
+    this._super(...arguments);
+    const { item_type: itemType } = this.paramsFor('vault.cluster.access.method.item');
+    const { path: method } = this.paramsFor('vault.cluster.access.method');
+    const { item_id: itemName } = this.paramsFor(this.routeName);
+    controller.set('itemType', singularize(itemType));
+    controller.set('mode', 'edit');
+    controller.set('method', method);
+    controller.set('itemName', itemName);
+  },
+});

ui/app/routes/vault/cluster/access/method/item/list.js

@@ -0,0 +1,45 @@
+import { inject as service } from '@ember/service';
+import Route from '@ember/routing/route';
+import { singularize } from 'ember-inflector';
+import ListRoute from 'vault/mixins/list-route';
+
+export default Route.extend(ListRoute, {
+  wizard: service(),
+  pathHelp: service('path-help'),
+  model() {
+    const { item_type: itemType } = this.paramsFor('vault.cluster.access.method.item');
+    const { page, pageFilter } = this.paramsFor(this.routeName);
+    const methodModel = this.modelFor('vault.cluster.access.method');
+    const { type } = methodModel;
+    let modelType = `generated-${singularize(itemType)}-${type}`;
+    const { path: method } = this.paramsFor('vault.cluster.access.method');
+
+    return this.store
+      .lazyPaginatedQuery(modelType, {
+        responsePath: 'data.keys',
+        page: page,
+        pageFilter: pageFilter,
+        type: itemType,
+        method: method,
+      })
+      .catch(err => {
+        if (err.httpStatus === 404) {
+          return [];
+        } else {
+          throw err;
+        }
+      });
+  },
+
+  setupController(controller) {
+    this._super(...arguments);
+    const { item_type: itemType } = this.paramsFor('vault.cluster.access.method.item');
+    let { path } = this.paramsFor('vault.cluster.access.method');
+    controller.set('itemType', singularize(itemType));
+    controller.set('method', path);
+    const { apiPath } = this.modelFor('vault.cluster.access.method');
+    this.pathHelp.getPaths(apiPath, path, itemType).then(paths => {
+      controller.set('paths', Array.from(paths.list, pathInfo => pathInfo.path));
+    });
+  },
+});

ui/app/routes/vault/cluster/access/method/item/show.js

@@ -0,0 +1,24 @@
+import { singularize } from 'ember-inflector';
+import { inject as service } from '@ember/service';
+import Route from '@ember/routing/route';
+
+export default Route.extend({
+  pathHelp: service('path-help'),
+  model() {
+    const { item_id: itemName } = this.paramsFor(this.routeName);
+    const { item_type: itemType } = this.paramsFor('vault.cluster.access.method.item');
+    const { path: method } = this.paramsFor('vault.cluster.access.method');
+    const methodModel = this.modelFor('vault.cluster.access.method');
+    const { type } = methodModel;
+    const modelType = `generated-${singularize(itemType)}-${type}`;
+    return this.store.findRecord(modelType, itemName, {
+      adapterOptions: { path: `${method}/${itemType}` },
+    });
+  },
+
+  setupController(controller) {
+    this._super(...arguments);
+    const { item_type: itemType } = this.paramsFor('vault.cluster.access.method.item');
+    controller.set('itemType', singularize(itemType));
+  },
+});

ui/app/routes/vault/cluster/access/method/section.js

@@ -25,5 +25,10 @@ export default Route.extend({
     const { section_name: section } = this.paramsFor(this.routeName);
     this._super(...arguments);
     controller.set('section', section);
+    let method = this.modelFor('vault.cluster.access.method');
+    if (method.type === 'ldap') {
+      let paths = method.paths.list.map(pathInfo => pathInfo.path);
+      controller.set('paths', paths);
+    }
   },
 });

ui/app/routes/vault/cluster/settings/auth/configure/index.js

@@ -4,8 +4,8 @@ import { tabsForAuthSection } from 'vault/helpers/tabs-for-auth-section';
 
 export default Route.extend({
   beforeModel() {
-    const type = this.modelFor('vault.cluster.settings.auth.configure').get('type');
-    const section = get(tabsForAuthSection([type]), 'firstObject.routeParams.lastObject');
+    const model = this.modelFor('vault.cluster.settings.auth.configure');
+    const section = get(tabsForAuthSection([model]), 'firstObject.routeParams.lastObject');
     return this.transitionTo('vault.cluster.settings.auth.configure.section', section);
   },
 });

ui/app/routes/vault/cluster/settings/auth/configure/section.js

@@ -37,7 +37,7 @@ export default Route.extend(UnloadModelRoute, {
     const backend = this.modelFor('vault.cluster.settings.auth.configure');
     const modelType = this.modelType(backend.type, section_name);
     let owner = getOwner(this);
-    return this.pathHelp.getNewModel(modelType, owner, method);
+    return this.pathHelp.getNewModel(modelType, owner, method, backend.apiPath);
   },
 
   model(params) {