import Ember from 'ember'
export default Ember.Route.extend({
model (params) {
return Ember.RSVP.hash({
cells: this.store.findAll('cell'),
homes: this.store.findAll('home'),
sections: this.store.findRecord('section', params.section_id, {reload: true})
})
}
})
options.query = function(query) {
var select2 = this;
if (self.get('_typeaheadMode')) {
var deferred = Ember.RSVP.defer('select2#query: ' + query.term);
self.sendAction('query', query, deferred);
deferred.promise.then(function(result) {
var data = result;
var more = false;
if (result instanceof Ember.ArrayProxy) {
data = result.toArray();
} else if (!Array.isArray(result)) {
if (result.data instanceof Ember.ArrayProxy) {
data = result.data.toArray();
} else {
data = result.data;
}
more = result.more;
}
query.callback({
results: data,
more: more
});
}, function(reason) {
query.callback({
hasError: true,
errorThrown: reason
});
});
} else {
Ember.assert("select2 has no content!", self.get('content'));
var filteredContent = self.get("content").reduce(function(results, item) {
// items may contain children, so filter them, too
var filteredChildren = [];
if (item.children) {
filteredChildren = item.children.reduce(function(children, child) {
if (select2.matcher(query.term, get(child, optionLabelPath)) || select2.matcher(query.term, get(child, optionHeadlinePath))) {
children.push(child);
}
return children;
}, []);
}
// apply the regular matcher
if (select2.matcher(query.term, get(item, optionLabelPath)) || select2.matcher(query.term, get(item, optionHeadlinePath))) {
// keep this item either if itself matches
results.push(item);
} else if (filteredChildren.length) {
// or it has children that matched the term
var result = Ember.$.extend({}, item, { children: filteredChildren });
results.push(result);
}
return results;
}, []);
query.callback({
results: filteredContent
});
}
};
import Ember from 'ember';
export default Ember.Route.extend({
titleToken() {
var app = this.modelFor('app');
return `Add an endpoint - ${app.get('handle')}`;
},
model() {
var app = this.modelFor('app');
var stack = app.get('stack');
return Ember.RSVP.hash({
vhost: this.store.createRecord('vhost', { app }),
services: app.get('services'),
vhosts: app.get('vhosts'),
certificates: stack.get('certificates'),
stack: stack
});
},
setupController(controller, model) {
var vhost = model.vhost,
services = model.services,
vhosts = model.vhosts,
certificates = model.certificates;
controller.set('model', vhost);
controller.set('services', services);
controller.set('vhosts', vhosts);
controller.set('certificates', certificates);
save: function () {
return Ember.RSVP.resolve();
}
let deployment = this.modelFor('deployment');
if (deployment.get('isStarted')) {
return;
}
let promises = {
deployment: deployment.save()
};
if (deployment.get('deploy_openstack')) {
promises.openstack_deployment = deployment.get('openstack_deployment')
.then(openstack_deployment => openstack_deployment.save());
}
return Ember.RSVP.hash(promises);
},
model() {
const reviewModel = this.modelFor('review');
const subModel = this.modelFor('subscriptions');
let modelHash = {reviewModel};
modelHash.subscriptionPools = this.loadSubscriptionPools();
if(subModel) {
// Use subscriptions model if the loading has already been done
modelHash.sessionPortal = subModel.sessionPortal;
modelHash.useExistingManifest = subModel.useExistingManifest;
if(modelHash.useExistingManifest) {
modelHash.subscriptions = subModel.subscriptions;
.then(function() {
controller = BalancedApp.__container__.lookup("controller:modals-container");
model = controller.get("currentModal.model");
sinon.stub(controller, "open").returns(Ember.RSVP.resolve());
sinon.stub(model, "save").returns(Ember.RSVP.resolve(model));
})
import Ember from 'ember';
import AuthenticatedRouteMixin from 'ember-simple-auth/mixins/authenticated-route-mixin';
import PaginatedFilteredRoute from '../../routes/paginated_filtered_route';
export default PaginatedFilteredRoute.extend(AuthenticatedRouteMixin, {
model(params) {
const test = this.modelFor('test');
return Ember.RSVP.hash({
test: test,
session: this.store.find('session', test.get('session_id')),
warnings: this.store.query('warning', {test_id: test.id, page: params.page})
});
},
setupController: function(controller, model) {
controller.setProperties(model);
}
});
import Ember from 'ember';
export default Ember.Route.extend({
model() {
return Ember.RSVP.hash({
rentals: this.store.findAll('rental'),
cities: this.store.findAll('city')
});
},
actions: {
destroyRental(rental) {
rental.destroyRecord();
this.transitionTo('index');
},
save3(params) {
var newRental = this.store.createRecord('rental', params);
newRental.save();
this.transitionTo('index');
},
update(rental, parameters) {
Object.keys(parameters).forEach(function(key){
if(parameters[key] !== undefined) {
rental[key] = parameters[key];
}
});
rental.save();
this.transitionTo('index');
}
}
});
/**
* [beforeUpload ]
*
* beforeUpload will send an 'beforeUpload' action
* if get false, then upload wont start
*
* @param {[type]} defer [description]
* @return {[type]} [description]
*/
beforeUpload(defer) {
if (!this.get('beforeUpload')) {
defer.resolve();
this.set('_recentUploadStatus', true);
return true;
} else {
const _defer = Ember.RSVP.defer();
_defer.promise.then((ret) => {
this.set('_recentUploadStatus', ret);
defer.resolve();
});
this.sendAction('beforeUpload', defer);
return false
}
},
/**
* [onProgress description]
* @param {[type]} event [description]
* @param {[type]} file [description]
* @return {[type]} [description]
*/
onProgress(event, file) {
}).catch(() => {
return Ember.RSVP.resolve();
}));
// Verify isAuthenticated: true is accurate, since Satellite session may have changed
const sessionPortal = this.modelFor('subscriptions').sessionPortal;
const cachedIsAuthenticated = sessionPortal.get('isAuthenticated');
if (cachedIsAuthenticated) {
return this.confirmAuthenticated(sessionPortal)
.then((isAuthenticated) => {
if(isAuthenticated) {
return sessionPortal;
} else {
sessionPortal.set('isAuthenticated', false);
return sessionPortal.save();
}
});
} else {
return Ember.RSVP.resolve(sessionPortal);
}
},
setupController(controller, model) {
controller.set('model', model);
controller.set('showErrorMessage', false);
},
deactivate() {
this.send('saveDeployment', null);
},
actions: {
error() {
// bubble up this error event:
}).catch(() => {
return Ember.RSVP.reject({type: 'error', message: 'Failed to retrieve cloned model'}) ;
});
schemas: this.get('userStore').find('schema'),
typeDocumentations: this.get('userStore').findAll('typedocumentation')
};
if ( params.machineId )
{
promises.clonedModel = this.getMachine(params.machineId);
}
if ( this.get('access.admin') ) {
let settings = this.get('settings');
promises.apiHostSet = settings.load(C.SETTING.API_HOST).then(() => {
return !!settings.get(C.SETTING.API_HOST);
});
} else {
promises.apiHostSet = Ember.RSVP.resolve(true);
}
return Ember.RSVP.hash(promises).then((hash) => {
hash.availableDrivers = this.get('machineDrivers');
let defaultDriver = this.get('defaultDriver');
let targetDriver = params.driver || this.get('lastDriver') || defaultDriver;
if ( ['custom','other'].indexOf(targetDriver) === -1 && hash.availableDrivers.filterBy('name', targetDriver).length === 0 )
{
targetDriver = defaultDriver;
}
if ( params.driver !== targetDriver )
{
selectPatient: function() {
let isNew = this.get('model.isNew');
let type = this.get('model.paymentType');
return (isNew && type === 'Deposit');
}.property('model.isNew', 'model.paymentType'),
beforeUpdate() {
if (this.get('model.isNew')) {
this.set('newPayment', true);
} else {
this.set('newPayment', false);
}
let patient = this.get('currentPatient');
this.set('model.charityPatient', patient.get('patientType') === 'Charity');
return Ember.RSVP.resolve();
},
afterUpdate() {
this.get('model').save().then(function(record) {
if (this.get('newPayment') === true) {
let patient = this.get('currentPatient');
patient.get('payments').then(function(payments) {
payments.addObject(record);
patient.save().then(function() {
if (record.get('paymentType') === 'Deposit') {
let message = `A deposit of ${record.get('amount')} was added for patient ${patient.get('displayName')}`;
this._finishUpdate(message, 'Deposit Added');
} else {
let invoice = this.get('model.invoice');
invoice.addPayment(record);
let dbServices = databases.then((dbs) => {
return Ember.RSVP.all(dbs.map((db) => db.get('service')).filter((service) => service));
});
import Ember from 'ember';
export default Ember.Route.extend({
model(){
return Ember.RSVP.hash({
goal: this.store.createRecord('goal'),
budget: this.store.createRecord('budget'),
});
},
setupController(controller, model){
Ember.set(controller, 'goal', model.goal);
Ember.set(controller, 'budget', model.budget);
}
});
.then(function() {
model = BalancedApp.__container__.lookup("controller:modals-container").get("currentModal.model");
sinon.stub(model, "save").returns(Ember.RSVP.reject(model));
})
zipHelper: function(options) {
var opts = options || {},
zipWriter,
completion = Ember.RSVP.defer(),
fileList = [],
completed = 0,
currentIdx = -1,
numFiles = 0,
hasMoreInputs = true,
inProgress = false,
hasFailed = false;
zip.createWriter(new zip.BlobWriter("application/zip"), function(writer) {
zipWriter = writer;
checkForCompletion();
nextFile();
});
function checkForCompletion() {
if (hasFailed) {
if (zipWriter) {
Ember.Logger.debug("aborting zipping. closing file.");
zipWriter.close(completion.reject);
zipWriter = null;
}
} else {
if (!hasMoreInputs && numFiles === completed) {
Ember.Logger.debug("completed zipping. closing file.");
zipWriter.close(completion.resolve);
}
}
}
function onProgress(current, total) {
if (Ember.$.isFunction(opts.onProgress)) {
opts.onProgress(fileList[currentIdx].name, current, total);
}
}
function onAdd(filename) {
if (Ember.$.isFunction(opts.onAdd)) {
opts.onAdd(filename);
}
}
function nextFile() {
if (hasFailed || completed === numFiles || inProgress) {
return;
}
currentIdx++;
var file = fileList[currentIdx];
inProgress = true;
onAdd(file.name);
zipWriter.add(file.name, new zip.TextReader(file.data), function() {
completed++;
inProgress = false;
if (currentIdx < numFiles - 1) {
nextFile();
}
checkForCompletion();
}, onProgress);
}
return DS.PromiseObject.create({
addFiles: function(files) {
files.forEach(this.addFile);
},
addFile: function(file) {
if (hasFailed) {
Ember.Logger.debug(`Skipping add of file ${file.name} as zip has been aborted`);
return;
}
numFiles++;
fileList.push(file);
if (zipWriter) {
Ember.Logger.debug("adding file from addFile: " + file.name);
nextFile();
}
},
close: function() {
hasMoreInputs = false;
checkForCompletion();
},
promise: completion.promise,
abort: function() {
hasFailed = true;
this.close();
}
});
}
import Ember from 'ember';
export default Ember.Route.extend({
model(params) {
return Ember.RSVP.hash({stock: this.store.findRecord('stock', params.symbol),
quotes: this.store.query('quote', {symbol: params.symbol})});
}
});
fileDownloader: function(options) {
var itemList = [],
opts = options || {},
numParallel = opts.numParallel || 5,
hasMoreInputs = true,
inProgress = 0,
hasFailed = false,
pendingRequests = {},
pendingRequestID = 0,
failureReason = 'Unknown',
deferredPromise = Ember.RSVP.defer();
function checkForCompletion() {
if (hasFailed) {
if (inProgress === 0) {
deferredPromise.reject("Unknown Error");
}
return;
}
if (hasMoreInputs || itemList.length > 0 || inProgress > 0) {
return;
}
deferredPromise.resolve();
}
function getRequestId() {
return "req_" + pendingRequestID++;
}
function abortPendingRequests() {
Ember.$.each(pendingRequests, function(idx, val) {
try {
val.abort("abort");
} catch(e) {}
});
}
function markFailed(reason) {
if (!hasFailed) {
hasFailed = true;
failureReason = reason;
abortPendingRequests();
}
}
function processNext() {
if (inProgress >= numParallel) {
Ember.Logger.debug(`delaying download as ${inProgress} of ${numParallel} is in progress`);
return;
}
if (itemList.length < 1) {
Ember.Logger.debug("no items to download");
checkForCompletion();
return;
}
inProgress++;
Ember.Logger.debug(`starting download ${inProgress}`);
var item = itemList.shift();
var xhr = Ember.$.ajax({
crossOrigin: true,
url: item.url,
dataType: 'json',
xhrFields: {
withCredentials: true
},
});
var reqID = getRequestId();
pendingRequests[reqID] = xhr;
if(item.onFetch) {
item.onFetch(item.context);
}
xhr.done(function(data/*, statusText, xhr*/) {
delete pendingRequests[reqID];
if (Ember.$.isFunction(item.onItemFetched)) {
try {
item.onItemFetched(data, item.context);
} catch (e) {
markFailed(e || 'failed to process data');
inProgress--;
checkForCompletion();
return;
}
}
inProgress--;
processNext();
}).fail(function(xhr, statusText/*, errorObject*/) {
delete pendingRequests[reqID];
inProgress--;
if(item.retryCount) {
itemList.unshift(item);
item.retryCount--;
if(item.onRetry) {
item.onRetry(item.context);
}
Ember.run.later(processNext, 3000 + Math.random() * 3000);
}
else if(item.onItemFail) {
item.onItemFail(xhr, item.context);
processNext();
}
else {
markFailed(statusText);
checkForCompletion();
}
});
}
return DS.PromiseObject.create({
promise: deferredPromise.promise,
queueItems: function(options) {
options.forEach(this.queueItem);
},
queueItem: function(option) {
itemList.push(option);
processNext();
},
finish: function() {
hasMoreInputs = false;
checkForCompletion();
},
cancel: function() {
markFailed("User cancelled");
checkForCompletion();
}
});
},
export default TabRoute.extend({
notifications: Ember.inject.service('notifications'),
model() {
const validations = {
nameValidation: {
name: [validatePresence({ presence: true })],
},
xpathValidation: {
xpath: [validatePresence({ presence: true })],
},
};
return Ember.RSVP.hash({
updatingCluster: this.store.peekAll('cluster'),
validations,
});
},
actions: {
delete(actionName, record) {
record.deleteRecord();
return this.get('notifications').notificationSaveRecord(record, actionName);
},
deleteMultiple(actionName, records) {
records.forEach((record) => {
record.deleteRecord();
return this.get('notifications').notificationSaveRecord(record, actionName);
});
},
addRole(attributes) {
save: function (options) {
var status,
prevStatus = this.get('model.status'),
isNew = this.get('model.isNew'),
autoSaveId = this.get('autoSaveId'),
timedSaveId = this.get('timedSaveId'),
self = this,
psmController = this.get('postSettingsMenuController'),
promise,
notifications = this.get('notifications');
options = options || {};
if (options.backgroundSave) {
// do not allow a post's status to be set to published by a background save
status = 'draft';
} else {
status = this.get('willPublish') ? 'published' : 'draft';
}
if (autoSaveId) {
Ember.run.cancel(autoSaveId);
this.set('autoSaveId', null);
}
if (timedSaveId) {
Ember.run.cancel(timedSaveId);
this.set('timedSaveId', null);
}
notifications.closePassive();
// ensure an incomplete tag is finalised before save
this.get('postTagsInputController').send('addNewTag');
// Set the properties that are indirected
// set markdown equal to what's in the editor, minus the image markers.
this.set('model.markdown', this.get('editor').getValue());
this.set('model.status', status);
// Set a default title
if (!this.get('model.titleScratch').trim()) {
this.set('model.titleScratch', '(Untitled)');
}
this.set('model.title', this.get('model.titleScratch'));
this.set('model.meta_title', psmController.get('metaTitleScratch'));
this.set('model.meta_description', psmController.get('metaDescriptionScratch'));
if (!this.get('model.slug')) {
// Cancel any pending slug generation that may still be queued in the
// run loop because we need to run it before the post is saved.
Ember.run.cancel(psmController.get('debounceId'));
psmController.generateAndSetSlug('model.slug');
}
promise = Ember.RSVP.resolve(psmController.get('lastPromise')).then(function () {
return self.get('model').save(options).then(function (model) {
if (!options.silent) {
self.showSaveNotification(prevStatus, model.get('status'), isNew ? true : false);
}
return model;
});
}).catch(function (errors) {
if (!options.silent) {
self.showErrorNotification(prevStatus, self.get('model.status'), errors);
}
self.set('model.status', prevStatus);
return self.get('model');
});
psmController.set('lastPromise', promise);
return promise;
},
import { moduleForComponent, test } from 'ember-qunit';
import hbs from 'htmlbars-inline-precompile';
import Ember from 'ember';
let mockPreview = Ember.Object.create({
markdown: 'A **body**',
body: 'A <strong>body</strong>',
save() {
return Ember.RSVP.resolve(this);
}
});
let mockStore = Ember.Service.extend({
createRecord() {
return mockPreview;
}
});
let mockMentionFetcher = Ember.Service.extend({
fetchBodyWithMentions() {
return Ember.RSVP.resolve('Lorem ipsum <strong>bla</strong>');
}
});
moduleForComponent('editor-with-preview', 'Integration | Component | editor with preview', {
integration: true,
beforeEach() {
this.register('service:store', mockStore);
this.register('service:mention-fetcher', mockMentionFetcher);
}
});
getNewData: function() {
return Ember.RSVP.resolve({
transactionType: 'Request',
requestedItems: []
});
},
model: function() {
return Ember.RSVP.hash({
bookingSlot: this.store.createRecord('booking-slot'),
days: this.store.all('day')
});
}
model: function() {
return Ember.RSVP.hash({
drafts: this.store.find('draft'),
stories: this.store.find('story')
});
}
const { inject, computed } = Ember;
const { service } = inject;
const { reads } = computed;
export default Ember.Service.extend(EventMixin, {
store: service(),
currentUser: service(),
session: service(),
ajax: service(),
serverVariables: service(),
namespace: reads('serverVariables.apiNameSpace'),
getEvents(from, to){
var deferred = Ember.RSVP.defer();
this.get('currentUser.model').then(user => {
if( user ){
var url = '/' + this.get('namespace') + '/userevents/' +
user.get('id') + '?from=' + from + '&to=' + to;
const ajax = this.get('ajax');
ajax.request(url).then(data => {
let events = data.userEvents.map(event => {
event.isBlanked = !event.offering && !event.ilmSession;
event.slug = this.getSlugForEvent(event);
return event;
}).sortBy('startDate');
deferred.resolve(events);
});
} else {
function arrayReduce(arr) {
return arr.reduce((prev, curr) => {
if(curr) {
return prev.toArray().concat(curr.toArray());
}
return prev;
}, Ember.A([]));
}
export default Ember.Route.extend({
model() {
let stacks = this.modelFor('organization.billing').stacks;
let databases = Ember.RSVP.all(stacks.map((stack) => stack.get('databases'))).then((dbs) => arrayReduce(dbs));
let apps = Ember.RSVP.all(stacks.map((stack) => stack.get('apps'))).then((apps) => arrayReduce(apps));
let appServices = apps.then((app) => arrayReduce(app.map((a) => a.get('services'))));
let dbServices = databases.then((dbs) => {
return Ember.RSVP.all(dbs.map((db) => db.get('service')).filter((service) => service));
});
let services = Ember.RSVP.all([appServices, dbServices]).then((s) => arrayReduce(s));
return Ember.RSVP.hash({
apps: apps,
stacks: stacks,
services: services,
model: function(params) {
return Ember.RSVP.hash({
movie: $.getJSON('http://www.omdbapi.com/?tomatoes=true&i=' + params.id).then(this.parseMovie),
poster: $.getJSON('https://api.themoviedb.org/3/find/' + params.id + '?api_key=227fe3bb4564a1ba35150061d97e905c&external_source=imdb_id').then(this.parsePoster),
});
},
import Ember from 'ember';
export default Ember.Route.extend({
map: Ember.inject.service('google-map'),
foursquare: Ember.inject.service('four-square'),
model(params){
return Ember.RSVP.hash({
city: params.query,
venues: this.get('foursquare').getVenues(params.query, 'food')
});
}
});