export default Route.extend({
queryParams: {
page: {
refreshModel: true,
},
pageFilter: {
refreshModel: true,
},
},
templateName: 'vault/cluster/access/leases/list',
model(params) {
const prefix = params.prefix || '';
if (this.modelFor('vault.cluster.access.leases').get('canList')) {
return hash({
leases: this.store
.lazyPaginatedQuery('lease', {
prefix,
responsePath: 'data.keys',
page: params.page,
pageFilter: params.pageFilter,
})
.then(model => {
this.set('has404', false);
return model;
})
.catch(err => {
if (err.httpStatus === 404 && prefix === '') {
return [];
} else {
throw err;
}
}),
capabilities: hash({
revokePrefix: this.store.findRecord('capabilities', `sys/leases/revoke-prefix/${prefix}`),
forceRevokePrefix: this.store.findRecord('capabilities', `sys/leases/revoke-force/${prefix}`),
}),
});
}
},
setupController(controller, model) {
const params = this.paramsFor(this.routeName);
const prefix = params.prefix ? params.prefix : '';
const has404 = this.get('has404');
controller.set('hasModel', true);
controller.setProperties({
model: model.leases,
capabilities: model.capabilities,
baseKey: { id: prefix },
has404,
});
if (!has404) {
const pageFilter = params.pageFilter;
let filter;
if (prefix) {
filter = prefix + (pageFilter || '');
} else if (pageFilter) {
filter = pageFilter;
}
controller.setProperties({
filter: filter || '',
page: model.leases.get('meta.currentPage'),
});
}
},
resetController(controller, isExiting) {
this._super(...arguments);
if (isExiting) {
controller.set('filter', '');
}
},
actions: {
error(error, transition) {
const { prefix } = this.paramsFor(this.routeName);
set(error, 'keyId', prefix);
const hasModel = this.controllerFor(this.routeName).get('hasModel');
// only swallow the error if we have a previous model
if (hasModel && error.httpStatus === 404) {
this.set('has404', true);
transition.abort();
} else {
return true;
}
},
willTransition(transition) {
window.scrollTo(0, 0);
if (transition.targetName !== this.routeName) {
this.store.clearAllDatasets();
}
return true;
},
},
});
export default Route.extend({
init: function() {
this._super(...arguments);
},
repo: service('dc'),
actions: {
loading: function(transition, originRoute) {
let dc = null;
if (originRoute.routeName !== 'dc') {
const model = this.modelFor('dc') || { dcs: null, dc: { Name: null } };
dc = get(this, 'repo').getActive(model.dc.Name, model.dcs);
}
hash({
loading: !$html.classList.contains('ember-loading'),
dc: dc,
}).then(model => {
next(() => {
const controller = this.controllerFor('application');
controller.setProperties(model);
transition.promise.finally(function() {
removeLoading();
controller.setProperties({
loading: false,
dc: model.dc,
});
});
});
});
return true;
},
error: function(e, transition) {
let error = {
status: e.code || '',
message: e.message || e.detail || 'Error',
};
if (e.errors && e.errors[0]) {
error = e.errors[0];
error.message = error.title || error.detail || 'Error';
}
if (error.status === '') {
error.message = 'Error';
}
const model = this.modelFor('dc');
hash({
error: error,
dc:
error.status.toString().indexOf('5') !== 0
? get(this, 'repo').getActive()
: model && model.dc
? model.dc
: { Name: 'Error' },
dcs: model && model.dcs ? model.dcs : [],
})
.then(model => {
removeLoading();
next(() => {
this.controllerFor('error').setProperties(model);
});
})
.catch(e => {
removeLoading();
next(() => {
this.controllerFor('error').setProperties({ error: error });
});
});
return true;
},
},
});
import { hash } from 'rsvp';
import { inject as service } from '@ember/service';
import Route from '@ember/routing/route';
import Fixtures from '../utils/fixtures';
export default Route.extend({
login: service(),
model() {
return hash({
tags : this.get('store').findAll('tag'),
statistics : this.get('store').findRecord('stat', 1),
tours : this.get('store').query('tourItem', {status : Fixtures.TourStatus.LAST_UPDATED})
});
},
setupController(controller, models) {
controller.set('tags', models.tags);
controller.set('stats', models.statistics);
controller.set('tours', models.tours);
controller.set('login', this.get('login'));
}
});
export default Route.extend({
globalStore: service(),
clusterStore: service(),
scope: service(),
model(params) {
const clusterStore = get(this, 'clusterStore');
const namespace = clusterStore.createRecord({
type: 'namespace',
name: '',
clusterId: get(this, 'scope.currentCluster.id'),
});
if (params.addTo) {
set(namespace, 'projectId', get(params, 'addTo'));
}
return hash({
namespace,
namespaces: get(this, 'clusterStore').findAll('namespace'),
allProjects: get(this, 'globalStore').findAll('project'),
});
},
resetController(controller, isExiting/* , transition*/) {
if (isExiting) {
controller.set('errors', null);
}
},
queryParams: {
addTo: { refreshModel: true },
from: { refreshModel: false }
},
});
export default Route.extend({
model () {
let items = [
{ name: 'item 0', idNum: '0', description: 'I\'m the item #0' },
{ name: 'item 1', idNum: '1', description: 'I\'m the item #1' },
{ name: 'item 2', idNum: '2', description: 'I\'m the item #2' },
{ name: 'item 3', idNum: '3', description: 'I\'m the item #3' },
{ name: 'item 4', idNum: '4', description: 'I\'m the item #4' },
{ name: 'item 5', idNum: '5', description: 'I\'m the item #5' },
{ name: 'item 6', idNum: '6', description: 'I\'m the item #6' },
{ name: 'item 7', idNum: '7', description: 'I\'m the item #7' },
{ name: 'item 8', idNum: '8', description: 'I\'m the item #8' },
{ name: 'item 9', idNum: '9', description: 'I\'m the item #9' },
{ name: 'item 10', idNum: '10', description: 'I\'m the item #10' },
{ name: 'item 11', idNum: '11', description: 'I\'m the item #11' },
{ name: 'item 12', idNum: '12', description: 'I\'m the item #12' },
{ name: 'item 13', idNum: '13', description: 'I\'m the item #13' },
{ name: 'item 14', idNum: '14', description: 'I\'m the item #14' },
{ name: 'item 15', idNum: '15', description: 'I\'m the item #15' },
{ name: 'item 16', idNum: '16', description: 'I\'m the item #16' },
{ name: 'item 17', idNum: '17', description: 'I\'m the item #17' },
{ name: 'item 18', idNum: '18', description: 'I\'m the item #18' },
{ name: 'item 19', idNum: '19', description: 'I\'m the item #19' },
{ name: 'item 20', idNum: '20', description: 'I\'m the item #20' },
{ name: 'item 21', idNum: '21', description: 'I\'m the item #21' },
{ name: 'item 22', idNum: '22', description: 'I\'m the item #22' },
{ name: 'item 23', idNum: '23', description: 'I\'m the item #23' },
{ name: 'item 24', idNum: '24', description: 'I\'m the item #24' },
{ name: 'item 25', idNum: '25', description: 'I\'m the item #25' },
{ name: 'item 26', idNum: '26', description: 'I\'m the item #26' },
{ name: 'item 27', idNum: '27', description: 'I\'m the item #27' },
{ name: 'item 28', idNum: '28', description: 'I\'m the item #28' },
{ name: 'item 29', idNum: '29', description: 'I\'m the item #29' },
{ name: 'item 30', idNum: '30', description: 'I\'m the item #30' }
]
return items.map((item) => {
return this.store.createRecord('item', item)
})
}
})
import Route from '@ember/routing/route'
import Paginate from '../mixins/table-pager/route'
export default Route.extend(Paginate, {
modelName: 'item',
// the name of the current controller since I don't know how to auto detect
controllerName: 'old',
queryParams: {
quickSearchField: {
refreshModel: true
},
q: {
refreshModel: true
}
}
})
import Route from '@ember/routing/route';
export default Route.extend({ });
import Route from '@ember/routing/route';
export default Route.extend({
/**
* A hook implemented to convert the URL into the model for this route.
*
* @override
* @public
* @function model
*
* @returns {Promise}
*/
model() {
return this.api.findAll('films');
}
});
import Route from '@ember/routing/route';
import { hash } from 'rsvp';
export default Route.extend({
titleToken: 'Company Anatomy',
model () {
return hash({
supervisors: this.store.query('employee', { $report: 'supervisors' }),
orgHead: this.store.query('employee', { $report: 'organizationHead' })
});
},
setupController (controller, model) {
controller.set('model', [ model.orgHead.get('firstObject'), ...model.supervisors.toArray() ].uniq());
}
});
import Route from "@ember/routing/route";
export default Route.extend({
model() {
return data;
},
setupController(controller, model) {
this._super(controller, model);
let data = model.map(function(record){
return { region: record.region, item: record.item, total: record.total}
})
controller.set("jsonData", data);
},
});
let data = [
{
order_date: "1/6/18",
region: "East",
rep: "Jones",
item: "Pencil",
units: 95,
cost: 1.99,
total: 189.05
},
{
order_date: "1/23/18",
region: "Central",
import Route from '@ember/routing/route';
import { inject as service } from '@ember/service';
import RestrictedRoute from 'ares-webportal/mixins/restricted-route';
export default Route.extend(RestrictedRoute, {
gameApi: service(),
session: service(),
model: function() {
let api = this.get('gameApi');
return api.requestMany('editPlugins');
}
});
import Route from '@ember/routing/route';
import { inject as service } from '@ember/service';
import RSVP from 'rsvp';
export default Route.extend({
ajax: service(),
account: service(),
model() {
let id = this.modelFor('flight').ids[0];
let flight = this.ajax.request(`/api/flights/${id}/`).then(it => it.flight);
let accountId = this.get('account.user.id');
let clubId = this.get('account.club.id');
let clubMembers = clubId
? this.ajax.request(`/api/users?club=${clubId}`).then(it => it.users.filter(user => user.id !== accountId))
: [];
return RSVP.hash({ id, flight, clubMembers });
},
});
import Route from '@ember/routing/route';
import { inject as service } from '@ember/service';
import AuthenticatedRouteMixin from 'ember-simple-auth/mixins/authenticated-route-mixin';
import { CanMixin } from 'ember-can';
export default Route.extend(AuthenticatedRouteMixin, CanMixin, {
session: service(),
beforeModel() {
let organization = this.modelFor('organizations.slugged-route');
if (this.cannot('manage organization', organization)) {
return this.transitionTo('index');
}
}
});
export default Route.extend(AuthenticatedRouteMixin, Navigation, UserRoles, {
session: service(),
beforeModel() {
let session = this.get('session');
if (!isEmpty(session)) {
let role = session.get('data.authenticated.role');
if (!isEmpty(role)) {
let userRole = this.findUserRole(role);
if (!isEmpty(userRole) && !isEmpty(userRole.defaultRoute)) {
let navelement = this.findNavItemByRoute(userRole.defaultRoute);
// validate that there really is a navigation element that matches that route.
if (!isEmpty(navelement)) {
return this.transitionTo(navelement.route);
}
}
}
}
return this._super(...arguments);
},
afterModel() {
this.controllerFor('application').set('allowSearch', false);
},
actions: {
createNewUser() {
return this.transitionTo('users.edit', 'new');
}
}
});
import { inject as service } from '@ember/service';
import Route from '@ember/routing/route';
export default Route.extend({
monthsService: service(),
async beforeModel() {
let currentMonth = await this.get("monthsService").findCurrentMonth();
this.transitionTo("months.view", currentMonth);
}
});
import { hash } from 'rsvp';
import Route from '@ember/routing/route';
import ComplexModelRoute from "../../mixins/complex-model-route";
import PollingRoute from "../../mixins/polling-route";
export default Route.extend(ComplexModelRoute, PollingRoute, {
should_auto_refresh() {
return true;
},
model() {
return hash({
migrations: this.store.query('migration', {}),
});
},
});
export default Route.extend(MarketingRouteMixin, UnauthenticatedRouteMixin, {
queryParams: { context: 'default' },
session: service(),
/**
* Model hook initializes and returns a new user record
*
* We can pass a context of the signup, e.g. `'donating'`
*/
model({ context }) {
let user = context ? { signUpContext: context } : {};
return get(this, 'store').createRecord('user', user);
},
resetController(controller, isExiting) {
if (isExiting) {
controller.set('context', 'default');
}
},
actions: {
signIn(credentials) {
get(this, 'session').authenticate('authenticator:jwt', credentials);
},
handleErrors(payload) {
if (isNonValidationError(payload)) {
set(this, 'controller.signup.error', payload);
}
}
}
});
import Route from '@ember/routing/route';
import AuthenticatedRoute from 'ares-webportal/mixins/authenticated-route';
import RouteResetOnExit from 'ares-webportal/mixins/route-reset-on-exit';
export default Route.extend(RouteResetOnExit, AuthenticatedRoute, {
model: function() {
return this.modelFor('application');
}
});
export default Route.extend({
templateName: 'vault/cluster/secrets/backend/list',
pathHelp: service('path-help'),
queryParams: {
page: {
refreshModel: true,
},
pageFilter: {
refreshModel: true,
},
tab: {
refreshModel: true,
},
},
secretParam() {
let { secret } = this.paramsFor(this.routeName);
return secret ? normalizePath(secret) : '';
},
enginePathParam() {
let { backend } = this.paramsFor('vault.cluster.secrets.backend');
return backend;
},
beforeModel() {
let owner = getOwner(this);
let secret = this.secretParam();
let backend = this.enginePathParam();
let { tab } = this.paramsFor('vault.cluster.secrets.backend');
let secretEngine = this.store.peekRecord('secret-engine', backend);
let type = secretEngine && secretEngine.get('engineType');
if (!type || !SUPPORTED_BACKENDS.includes(type)) {
return this.transitionTo('vault.cluster.secrets');
}
if (this.routeName === 'vault.cluster.secrets.backend.list' && !secret.endsWith('/')) {
return this.replaceWith('vault.cluster.secrets.backend.list', secret + '/');
}
let modelType = this.getModelType(backend, tab);
return this.pathHelp.getNewModel(modelType, owner, backend).then(() => {
this.store.unloadAll('capabilities');
});
},
getModelType(backend, tab) {
let secretEngine = this.store.peekRecord('secret-engine', backend);
let type = secretEngine.get('engineType');
let types = {
transit: 'transit-key',
ssh: 'role-ssh',
aws: 'role-aws',
pki: tab === 'certs' ? 'pki-certificate' : 'role-pki',
// secret or secret-v2
cubbyhole: 'secret',
kv: secretEngine.get('modelTypeForKV'),
generic: secretEngine.get('modelTypeForKV'),
};
return types[type];
},
model(params) {
const secret = this.secretParam() || '';
const backend = this.enginePathParam();
const backendModel = this.modelFor('vault.cluster.secrets.backend');
return hash({
secret,
secrets: this.store
.lazyPaginatedQuery(this.getModelType(backend, params.tab), {
id: secret,
backend,
responsePath: 'data.keys',
page: params.page,
pageFilter: params.pageFilter,
})
.then(model => {
this.set('has404', false);
return model;
})
.catch(err => {
// if we're at the root we don't want to throw
if (backendModel && err.httpStatus === 404 && secret === '') {
return [];
} else {
// else we're throwing and dealing with this in the error action
throw err;
}
}),
});
},
afterModel(model) {
const { tab } = this.paramsFor(this.routeName);
const backend = this.enginePathParam();
if (!tab || tab !== 'certs') {
return;
}
return all(
// these ids are treated specially by vault's api, but it's also
// possible that there is no certificate for them in order to know,
// we fetch them specifically on the list page, and then unload the
// records if there is no `certificate` attribute on the resultant model
['ca', 'crl', 'ca_chain'].map(id => this.store.queryRecord('pki-certificate', { id, backend }))
).then(
results => {
results.rejectBy('certificate').forEach(record => record.unloadRecord());
return model;
},
() => {
return model;
}
);
},
setupController(controller, resolvedModel) {
let secretParams = this.paramsFor(this.routeName);
let secret = resolvedModel.secret;
let model = resolvedModel.secrets;
let backend = this.enginePathParam();
let backendModel = this.store.peekRecord('secret-engine', backend);
let has404 = this.get('has404');
// only clear store cache if this is a new model
if (secret !== controller.get('baseKey.id')) {
this.store.clearAllDatasets();
}
controller.set('hasModel', true);
controller.setProperties({
model,
has404,
backend,
backendModel,
baseKey: { id: secret },
backendType: backendModel.get('engineType'),
});
if (!has404) {
const pageFilter = secretParams.pageFilter;
let filter;
if (secret) {
filter = secret + (pageFilter || '');
} else if (pageFilter) {
filter = pageFilter;
}
controller.setProperties({
filter: filter || '',
page: model.get('meta.currentPage') || 1,
});
}
},
resetController(controller, isExiting) {
this._super(...arguments);
if (isExiting) {
controller.set('filter', '');
}
},
actions: {
error(error, transition) {
let secret = this.secretParam();
let backend = this.enginePathParam();
let is404 = error.httpStatus === 404;
let hasModel = this.controllerFor(this.routeName).get('hasModel');
// this will occur if we've deleted something,
// and navigate to its parent and the parent doesn't exist -
// this if often the case with nested keys in kv-like engines
if (transition.data.isDeletion && is404) {
throw error;
}
set(error, 'secret', secret);
set(error, 'isRoot', true);
set(error, 'backend', backend);
// only swallow the error if we have a previous model
if (hasModel && is404) {
this.set('has404', true);
transition.abort();
return false;
}
return true;
},
willTransition(transition) {
window.scrollTo(0, 0);
if (transition.targetName !== this.routeName) {
this.store.clearAllDatasets();
}
return true;
},
reload() {
this.store.clearAllDatasets();
this.refresh();
},
},
});
import Route from '@ember/routing/route';
import { task, timeout } from 'ember-concurrency';
export default Route.extend({
setupController() {
this.get('loopingTask').perform();
},
loopingTask: task(function * () {
while(true) {
this.controller.incrementProperty('foo');
yield timeout(200);
}
}),
});
import Route from '@ember/routing/route';
export default Route.extend({
model: function() {
return this.modelFor('event').getStartTime();
},
actions: {
runnerClicked: function(runner) {
this.transitionTo('event.categories.category.runner', runner.category, runner.id);
},
runnerOver: function(runner) {
this.get('controller').set('hoverRunner', runner);
}
}
});
import Route from '@ember/routing/route';
export default Route.extend({
model(params) {
return this.store.findRecord('performance', params.id);
},
actions: {
willTransition(/*transition*/) {
let performance = this.modelFor(this.routeName);
if (performance.get('hasDirtyAttributes')) {
performance.rollbackAttributes();
}
}
}
});
import Route from '@ember/routing/route';
import { hash } from 'rsvp';
export default Route.extend({
model(params) {
var sighting = this.store.findRecord('sighting', params.sighting_id);
var cryptids = this.store.findAll('cryptid');
var witnesses = this.store.findAll('witness');
return hash({
sighting: sighting,
cryptids: cryptids,
witnesses: witnesses
});
}
});
import Route from '@ember/routing/route';
export default Route.extend({
queryParams: {
page: { refreshModel: true },
sort: { refreshModel: true },
},
model(params) {
return this.store.query('category-slug', params);
},
});
export default Route.extend({
model(params) {
if (params.verify_token) {
this.set('params', params);
return fetch('/verify-token', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ token: params.verify_token })
}).then((resp) => {
if (resp.status >= 200 && resp.status < 300) {
return resp.body;
}
})
.catch((err) => reject(err.body));
} else {
this.transitionTo('/');
}
},
setupController(controller, model) {
this._super(controller, model);
controller.set('token', this.get('params.verify_token'));
},
activate() {
$('BODY').addClass('container-farm'); // eslint-disable-line
},
deactivate() {
$('BODY').removeClass('container-farm'); // eslint-disable-line
},
});
import { inject as service } from '@ember/service';
import Route from '@ember/routing/route';
import RSVP from 'rsvp';
export default Route.extend({
ajax: service(),
model() {
let id = this.modelFor('flight').ids[0];
let flight = this.get('ajax').request(`/api/flights/${id}/`).then(it => it.flight);
let aircraftModels = this.get('ajax').request('/api/aircraft-models').then(it => it.models);
return RSVP.hash({ id, flight, aircraftModels });
},
});
import Route from '@ember/routing/route';
import { inject as service } from '@ember/service';
import RSVP from 'rsvp';
export default Route.extend({
emberFreestyle: service(),
beforeModel() {
let emberFreestyle = this.get('emberFreestyle');
return emberFreestyle.ensureHljs().then(() => {
return RSVP.all([
emberFreestyle.ensureHljsLanguage('handlebars'),
emberFreestyle.ensureHljsLanguage('htmlbars'),
]);
});
},
});
export default Route.extend(add, {
titleToken: 'New User',
auth: service(),
modelName: 'company-user',
getModelDefaults () {
return { company: this.get('auth.user.company') };
},
model () {
return RSVP.hash({
permissions: this.store.findAll('permission'),
user: this._super(...arguments),
employees: this.store.query('employee', { _id: { $ne: this.get('auth.user.employee.id') } })
});
},
setupController (controller, model) {
controller.setProperties({
model: model.user,
employees: model.employees,
permissions: model.permissions,
permissionsTree: model.permissions.toArray().reduce((parents, permission) => {
let { id, key } = permission,
verb = key.split(' ').shift();
verb = crud.includes(verb) ? verb : 'other';
if (!parents.findBy('name', verb)) {
parents.push(Object.assign({
id: verb,
name: verb,
children: []
}, nodeDefaults));
}
parents.findBy('name', verb).children.push(
Object.assign({
id,
name: key
}, nodeDefaults)
);
return parents;
}, A()).toArray()
});
}
});
export default Route.extend({
init() {
this._super(...arguments);
this.keyboardShortcuts = {
s: {
action: 'myAction', // action to trigger
global: false, // whether to trigger inside input (default: true)
preventDefault: true // (default: true)
}
};
},
actions: {
myAction() {
alert('key `s` was pressed');
}
},
activate() {
this._super(...arguments);
bindKeyboardShortcuts(this);
},
deactivate() {
this._super(...arguments);
unbindKeyboardShortcuts(this);
}
});
import Route from '@ember/routing/route';
export default Route.extend({
actions: {
cancel() {
this.transitionTo('security.authentication');
}
},
});