/**
* `CircleLayer` is a circle on the map that adjusts based
* on a content object that should be an array of LatLng objects.
*
* @class CircleLayer
* @extends PointPathLayer
*/
export default PointPathLayer.extend({
/**
If this property is null, watch the content object for radius updates.
If this property is set, look inside this property of the content object
for the radius.
*/
radius: Ember.computed.alias('content.radius'),
_updateLayerOnRadiusChange: Ember.observer('radius', function() {
var newRadius = get(this, 'radius');
if(newRadius && !this._layer) {
this._createLayer();
} else if(this._layer && !newRadius) {
this._destroyLayer();
} else {
var oldRadius = this._layer && this._layer.getRadius();
if(oldRadius && newRadius && (oldRadius !== newRadius)) {
this._layer.setRadius(newRadius);
}
}
}),
import Ember from 'ember';
export default Ember.Component.extend({
bookmarkedQuestions: Ember.inject.service(),
sortBy: ['body:asc'],
sortedQuestions: Ember.computed.sort('questions', 'sortBy'),
actions: {
update(question, params) {
this.sendAction('update', question, params);
},
addToBookmarks(questions) {
this.get('bookmarkedQuestions').add(questions);
}
}
});
import Ember from 'ember';
export default Ember.Controller.extend({
sortProperties: ['id'],
sortedSubcategories: Ember.computed.sort('model.subcategories', 'sortProperties')
});
import Ember from 'ember';
import StyleBindingsMixin from '../mixins/style-bindings-mixin';
/*
We hacked this. There is an inconsistency at the level in which we are
handling scroll event...
*/
var HeaderRow;
HeaderRow = Ember.View.extend(StyleBindingsMixin, {
templateName: 'header-row',
classNames: ['ember-table-table-row', 'ember-table-header-row'],
styleBindings: ['width'],
columns: Ember.computed.alias('content'),
width: Ember.computed.alias('controller._rowWidth'),
scrollLeft: Ember.computed.alias('controller._tableScrollLeft'),
/* Options for jQuery UI sortable */
sortableOption: Ember.computed(function() {
return {
axis: 'x',
containment: 'parent',
cursor: 'move',
helper: 'clone',
items: ".ember-table-header-cell.sortable",
opacity: 0.9,
placeholder: 'ui-state-highlight',
scroll: true,
tolerance: 'intersect',
update: jQuery.proxy(this.onColumnSortDone, this),
stop: jQuery.proxy(this.onColumnSortStop, this),
'c3.large','c3.xlarge','c3.2xlarge','c3.4xlarge','c3.8xlarge',
'r3.large','r3.xlarge','r3.2xlarge','r3.4xlarge','r3.8xlarge',
'g2.2xlarge','g2.8xlarge',
'i2.xlarge','i2.2xlarge','i2.4xlarge','i2.8xlarge',
'd2.xlarge','d2.2xlarge','d2.4xlarge','d2.8xlarge',
];
export default Ember.ObjectController.extend(NewHost, {
clients: null,
allSubnets: null,
allSecurityGroups: null,
selectedSecurityGroup: null,
defaultSecurityGroup: null,
defaultSecurityGroupName: RANCHER_GROUP,
whichSecurityGroup: 'default',
isCustomSecurityGroup: Ember.computed.equal('whichSecurityGroup','custom'),
instanceTypes: INSTANCE_TYPES,
step: 1,
isStep1: Ember.computed.equal('step',1),
isStep2: Ember.computed.equal('step',2),
isStep3: Ember.computed.equal('step',3),
isStep4: Ember.computed.equal('step',4),
isStep5: Ember.computed.equal('step',5),
isStep6: Ember.computed.equal('step',6),
isStep7: Ember.computed.equal('step',7),
isGteStep3: Ember.computed.gte('step',3),
isGteStep4: Ember.computed.gte('step',4),
isGteStep5: Ember.computed.gte('step',5),
isGteStep6: Ember.computed.gte('step',6),
isGteStep7: Ember.computed.gte('step',7),
/**
* Ember controller for wwoofer edition.
*/
import Ember from 'ember';
export default Ember.ObjectController.extend({
needs: ['application', 'wwoofer', 'countries', 'departments', 'user/memberships'],
// Setup bindings used in partial
hasWwoofMemberships: Ember.computed.oneWay('controllers.user/memberships.hasWwoofMemberships'),
latestWwoofMembership: Ember.computed.oneWay('controllers.user/memberships.latestWwoofMembership'),
belongsToCurrentUser: Ember.computed.oneWay('controllers.wwoofer.belongsToCurrentUser'),
actions: {
saveWwoofer: function () {
var wwoofer = this.get('model');
var address = wwoofer.get('address');
// Prevent multiple save attempts
if (this.get('isSaving')) {
return;
}
// Initialize validations array
var validations = Ember.makeArray(wwoofer.validate());
validations.push(address.validate());
// Validate wwoofer and address
var self = this;
Ember.RSVP.all(validations).then(function () {
errorPassword: false,
successPassword: false,
errorPasswordConfirmation: false,
successPasswordConfirmation: false,
errorPassword2: false,
successPassword2: false,
errorGroup: false,
successGroup: false,
// project sorting
projectSorting: ['name'],
projectSort: Ember.computed.sort('projects', 'projectSorting'),
// trigger function when model changes
didReceiveAttrs() {
this._super(...arguments);
this.cleanModel();
this.initBuffer();
this.initModel();
},
// Filter groups display follow access_level user
groupsFilter: function() {
var access_level = this.get('session').get('data.authenticated.access_level');
var current_id = this.get('session').get('data.authenticated.user.id');
var user_id = this.get('user.id');
import Ember from 'ember';
export default Ember.ArrayController.extend({
queryParams: ['q', 'countries', 'sources', 'page', 'name', 'address', 'start_date', 'end_date', 'expiration_date', 'issue_date', 'fuzzy_name'],
q: null,
qField: Ember.computed.oneWay('q'),
name: null,
nameField: Ember.computed.oneWay('name'),
address: null,
addressField: Ember.computed.oneWay('address'),
start_date: null,
startDateFieldStart: null,
startDateFieldEnd: null,
end_date: null,
endDateFieldStart: null,
endDateFieldEnd: null,
expiration_date: null,
expirationDateFieldStart: null,
expirationDateFieldEnd: null,
issue_date: null,
issueDateFieldStart: null,
issueDateFieldEnd: null,
countries: null,
import Ember from 'ember';
import C from 'ui/utils/constants';
export default Ember.Controller.extend({
application : Ember.inject.controller(),
settings : Ember.inject.service(),
projects : Ember.inject.service(),
currentPath : Ember.computed.alias('application.currentPath'),
error : null,
isPopup: Ember.computed.alias('application.isPopup'),
hasCattleSystem: function() {
var out = false;
(this.get('model.stacks')||[]).forEach((stack) => {
var info = stack.get('externalIdInfo');
if ( C.EXTERNALID.SYSTEM_KINDS.indexOf(info.kind) >= 0 )
{
out = true;
}
});
return out;
}.property('*****@*****.**'),
hasHosts: function() {
return (this.get('model.hosts.length') > 0) || (this.get('model.machines.length') > 0);
}.property('model.{hosts,machines}'),
isReady: function() {
return this.get('projects.isReady') && this.get('hasHosts');
import Ember from "ember";
export default Ember.ArrayController.extend({
propertiesToSortBy: ['id:desc', 'name'],
sortedPlayers: Ember.computed.sort('content', 'propertiesToSortBy'),
actions: {
addPlayer: function() {
var name = this.get('newPlayerName');
if( !name ){ return false; }
if( !name.trim() ){ return; }
var player = this.store.createRecord('player', {
id: Date.now(),
name: name
});
this.set('newPlayerName', "");
player.save();
// this.store.find('player', { email: "*****@*****.**" }).then(function(player) {
// post.set('author', user);
// });
}
}
});
import Ember from 'ember';
import { alternateLabel } from 'ui/utils/platform';
import ModalBase from 'lacsso/components/modal-base';
export default ModalBase.extend({
classNames: ['lacsso', 'modal-container', 'span-6', 'offset-3', 'modal-logs'],
originalModel : Ember.computed.alias('modalService.modalOpts.originalModel'),
action : Ember.computed.alias('modalService.modalOpts.action'),
alternateLabel : alternateLabel,
intl : Ember.inject.service(),
actions: {
confirm: function() {
this.get('originalModel').send(this.get('action'));
this.send('cancel');
},
},
didRender: function() {
setTimeout(() => {
this.$('BUTTON')[0].focus();
}, 500);
},
isService: Ember.computed('originalModel.type','intl._locale', function() {
let type = this.get('originalModel.type');
let out = {};
let intl = this.get('intl');
switch (type) {
import NewOrEdit from 'ui/mixins/new-or-edit';
import Ember from 'ember';
export default Ember.Component.extend(NewOrEdit, {
existing: Ember.computed.alias('originalModel'),
editing: true,
service: null,
primaryResource: Ember.computed.alias('service'),
actions: {
done() {
this.sendAction('dismiss');
},
cancel() {
this.sendAction('dismiss');
},
},
init() {
this._super(...arguments);
var original = this.get('originalModel');
this.set('service', original.clone());
},
doneSaving: function() {
this.send('done');
},
didInsertElement() {
import Ember from 'ember';
export default Ember.Component.extend({
sortBy: ['timestamp:desc'],
sortedListings: Ember.computed.sort('category.listings', 'sortBy'),
});
};
$el.hover(function(event){
self.displayAlertErrors();
});
$el.find(':input').focus(function(event){
return self.displayAlertErrors();
});
$el.find(":input").blur(function(event) {
return makeShowValidationErrors();
});
$el.closest("form").submit(function() {
makeShowValidationErrors();
});
},
isLegacyModel: Ember.computed.none("model.errors"),
errorMessages: Ember.computed.reads("errorMessagesIndirectionHandler.messages"),
isOneError: Ember.computed.equal("errorMessages.length", 1),
errorMessagesIndirectionHandler: Ember.computed("isLegacyModel", "model", "field", function() {
var errorsListKeyName,
fieldName = this.get("field"),
model = this.get("model");
if (!this.get("isLegacyModel")) {
errorsListKeyName = "model.errors." + fieldName;
} else {
errorsListKeyName = "model.validationErrors." + fieldName + ".messages";
}
return Ember.Object.extend({
messages: Ember.computed.reads(errorsListKeyName)
}).create({
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import Ember from 'ember';
import constants from 'hive/utils/constants';
export default Ember.Controller.extend({
needs: [ constants.namingConventions.index ],
index: Ember.computed.alias('controllers.' + constants.namingConventions.index),
tezViewURL: null,
tezApiURL: '/api/v1/views/TEZ',
tezURLPrefix: '/views/TEZ',
tezDagPath: '?viewPath=/#/dag/',
isTezViewAvailable: Ember.computed.bool('tezViewURL'),
dagId: function () {
if (this.get('isTezViewAvailable')) {
return this.get('index.model.dagId');
}
return false;
}.property('index.model.dagId', 'isTezViewAvailable'),
import Ember from 'ember';
import sortBy from '../../utils/sort-by';
export default Ember.Controller.extend({
showExplanation: false,
showBadgeText: false,
categories: function() {
return this.get('store').peekAll('category').sortBy('displayName');
}.property(),
//BUG: See https://github.com/emberjs/data/issues/2666
keywords: Ember.computed.filterBy('model.keywords', 'isDeleted', false),
maintainers: Ember.computed.filterBy('model.maintainers', 'isDeleted', false),
licenseUrl: function() {
return `https://spdx.org/licenses/${this.get('model.license')}`;
}.property('model.license'),
sortedReviews: sortBy('model.reviews', 'version.released:desc'),
latestReview: Ember.computed.alias('sortedReviews.firstObject'),
isLatestReleaseInLast3Months: function() {
if (!this.get('model.latestVersion.released')) { return false; }
var threeMonthsAgo = window.moment().subtract(3, 'months');
return window.moment(this.get('model.latestVersion.released')).isAfter(threeMonthsAgo);
}.property('model.latestVersion.released'),
isLatestReviewForLatestVersion: function() {
return this.get('latestReview') === this.get('model.latestVersion.review');
}.property('latestReview', 'model.latestVersion.review'),
badgeText: function() {
return `[}.svg)](http://emberobserver.com/addons/${this.get('model.name')})`;
}.property('model.name'),
installCommandText: function() {
import Ember from 'ember';
const CONFIG_DEFAULTS = {
mode: 'whitelist',
paths: [],
};
export default Ember.Controller.extend({
flashMessages: Ember.inject.service(),
rm: Ember.inject.service('replication-mode'),
replicationMode: Ember.computed.alias('rm.mode'),
actions: {
resetConfig(config) {
if (config.get('isNew')) {
config.setProperties(CONFIG_DEFAULTS);
} else {
config.rollbackAttributes();
}
},
saveConfig(config, isDelete) {
const flash = this.get('flashMessages');
const id = config.id;
const redirectArgs = isDelete
? [
'vault.cluster.replication.mode.secondaries',
this.model.cluster.get('name'),
this.get('replicationMode'),
]
: ['vault.cluster.replication.mode.secondaries.config-show', id];
const modelMethod = isDelete ? config.destroyRecord : config.save;
import Ember from 'ember';
import NeedsDeploymentMixin from "../../mixins/needs-deployment-mixin";
import PaginationControllerMixin from "../../mixins/pagination-controller-mixin";
import FilterSortHostsMixin from "../../mixins/filter-sort-hosts-mixin";
export default Ember.Controller.extend(NeedsDeploymentMixin, PaginationControllerMixin, FilterSortHostsMixin, {
sortRoute: "engine.discovered-host",
rhevController: Ember.inject.controller('rhev'),
selectedRhevEngineHost: Ember.computed.alias("model"),
hypervisorModelIds: Ember.computed('deploymentController.model.discovered_hosts.[]', function() {
return this.get('deploymentController.model.discovered_hosts').getEach('id');
}),
engineNextRouteName: Ember.computed('rhevIsSelfHosted', function() {
if (this.get('rhevIsSelfHosted')) {
return 'rhev-options';
} else {
return 'hypervisor.discovered-host';
}
}),
// Filter out hosts selected as Hypervisor
availableHosts: Ember.computed('deployingHosts', 'allDiscoveredHosts.[]', 'hypervisorModelIds.[]', function() {
let allDiscoveredHosts = this.get('allDiscoveredHosts');
if (Ember.isEmpty(allDiscoveredHosts)) {
import Ember from 'ember';
export default Ember.Component.extend({
community: Ember.computed.alias('model'),
});
registryCredentialId : null,
command : null,
commandArgs : null,
environment : null,
ports : null,
instanceLinks : null,
dataVolumes : null,
dataVolumesFrom : null,
devices : null,
restartPolicy : null,
_allMounts : null,
primaryHost : denormalizeId('hostId', 'host'),
services : denormalizeIdArray('serviceIds'),
primaryService : Ember.computed.alias('services.firstObject'),
reservedKeys: [
'_allMounts',
],
init: function() {
this._super();
// this.get('store') isn't set yet at init
var store = getOwner(this).lookup('service:store');
if ( !_allMounts )
{
_allMounts = store.allUnremoved('mount');
}
import Ember from 'ember';
export default Ember.Controller.extend({
isValid: Ember.computed.match('emailAddress', /^.+@.+\..+$/),
isDisabled: Ember.computed.not('isValid'),
emailAddress: '',
headerMessage: 'Coming Soon',
responseMessage: '',
actions: {
saveInvitation() {
const email = this.get('emailAddress');
const newInvitation = this.store.createRecord('invitation', {email: email});
newInvitation.save().then((response) => {
this.set('responseMessage', `Thank you! We've just saved your email address with the following id:
${response.get('id')}`);
this.set('emailAddress', '');
});
}
}
});
import Ember from 'ember';
export default Ember.ObjectController.extend({
needs: ['board'],
board: Ember.computed.alias('controllers.board'),
actions: {
deleteSwimlane: function() {
var swimlane = this.get('model');
var board = this.get('board.model');
board.get('swimlanes').then(function(swimlanes) {
swimlanes.removeObject(swimlane);
board.save();
swimlane.get('cards').then(function(cards) {
cards.forEach(function(card) {
card.destroyRecord();
});
swimlane.destroyRecord();
});
});
}
}
});
import Ember from "ember";
import IsUpdateDisabled from "hospitalrun/mixins/is-update-disabled";
import GenderList from 'hospitalrun/mixins/gender-list';
import NewBelieverInfo from 'hospitalrun/mixins/new-believer-info';
export default Ember.ObjectController.extend(IsUpdateDisabled, GenderList, NewBelieverInfo, {
needs: 'ministry/edit',
editController: Ember.computed.alias('controllers.ministry/edit'),
actions: {
cancel: function() {
this.send('closeModal');
},
add: function() {
var newBeliever = this.getProperties('believerName', 'religiousAffiliation',
'presentActivity', 'declarationType', 'age', 'gender',
'phone', 'email', 'address', 'country');
this.get('editController').send('addBeliever', newBeliever);
},
update: function() {
var believers = this.get('editController').get('believers');
var believer = this.get('believerToEdit');
console.log(believers);
console.log(believer);
// delete old info that exist
believers.removeObject(believer);
var updatedBeliever = this.getProperties('believerName', 'religiousAffiliation',
* @extends Ember.Mixin
*/
export default Ember.Mixin.create({
/**
* The list of comments associated with a model. Defaults to using the model hook, and ensures that new comments
* are shown first (to match API convention)
*
* @public
* @property comments
* @type Comment[]
*/
comments: Ember.computed.sort('model.comments', function(a, b) {
// As new records are added, they do not necessarily respect the newest-first ordering used by the API. Enforce.
// FIXME: Until the API returns, newly added comments may not have creation date set, in which case sorting fails. Assume anything without a date is new.
let aTime = a.get('dateCreated') || new Date();
let bTime = b.get('dateCreated') || new Date();
return bTime - aTime;
}),
actions: {
/**
* Action that adds a new comment targeting the model by GUID.
* @method addComment
* @param {String} text The text of the new comment
* @return {Promise} The newly created comment
*/
addComment(text) {
// Assumes that the page's model hook is the target for the comment
let model = this.get('model');
var commentsRel = model.get('comments');
import AbstractEditController from 'hospitalrun/controllers/abstract-edit-controller';
import InventorySelection from 'hospitalrun/mixins/inventory-selection';
import Ember from "ember";
export default AbstractEditController.extend(InventorySelection, {
needs: ['procedures/edit'],
cancelAction: 'closeModal',
newPricingItem: false,
requestingController: Ember.computed.alias('controllers.procedures/edit'),
medicationList: Ember.computed.alias('controllers.procedures/edit.medicationList'),
updateCapability: 'add_charge',
medicationChanged: function() {
var itemName = this.get('itemName'),
medication = this.get('medication');
if (!Ember.isEmpty(medication) && medication.get('name') !== itemName) {
this.set('itemName', medication.get('name'));
}
}.observes('medication'),
title: function() {
var isNew = this.get('isNew');
if (isNew) {
return 'Add Medication Used';
}
return 'Edit Medication Used';
}.property('isNew'),
beforeUpdate: function() {
var isNew = this.get('isNew');
return this.get('model.questions').objectAt(this.get('questionIndex'));
}),
filters: Ember.A([]),
filteredBens: Ember.computed('model.bens.@each', 'filters.[]', function() {
var filteredBens = this.get('model.bens');
var filters = this.get('filters');
filters.forEach(function(filter) {
filteredBens = filteredBens.filterBy(filter.get('property'), filter.get('value'));
});
return filteredBens;
}),
noBensLeft: Ember.computed.equal('filteredBens.length', 0),
showUnsure: Ember.computed('noBensLeft', 'currentQuestion', function() {
var noBensLeft = this.get('noBensLeft');
var currentQuestion = this.get('currentQuestion');
if (noBensLeft || !currentQuestion) {
return true;
} else {
return false;
}
}),
reset: function() {
this.get('filters').forEach(function(filter) {
filter.deleteRecord();
});
import Ember from 'ember';
export default Ember.Component.extend({
auth: Ember.inject.service(),
sale: Ember.inject.service(),
user: Ember.computed.alias('auth.credentials.email'),
isAuthenticated: Ember.computed.alias('auth.isAuthenticated'),
actions: {
signOut () {
this.get('sale').clearOrder();
this.sendAction('signOut');
},
}
});
import Ember from 'ember';
export default Ember.Controller.extend({
hasEmail: Ember.computed.notEmpty('model.email'),
hasFirstName: Ember.computed.notEmpty('model.firstName'),
hasLastName: Ember.computed.notEmpty('model.lastName'),
hasTwitter: Ember.computed.notEmpty('model.twitter'),
isValid: Ember.computed.and(
'hasEmail',
'hasFirstName',
'hasLastName',
'hasTwitter'
),
actions: {
save: function() {
if (this.get('isValid')) {
var _this = this;
this.get('model').save().then(function(friend) { _this.transitionToRoute('friends.show', friend);
});
} else {
this.set('errorMessage', 'You have to fill all the fields'); }
return false;
},
cancel: function() {
return true;
}
}
});
import Ember from 'ember';
import Cattle from 'ui/utils/cattle';
import C from 'ui/utils/constants';
import ReadLabels from 'ui/mixins/read-labels';
var ServiceController = Cattle.TransitioningResourceController.extend(ReadLabels, {
needs: ['environment'],
environment: Ember.computed.alias('controllers.environment'),
labelResource: Ember.computed.alias('model.launchConfig'),
actions: {
activate: function() {
return this.doAction('activate');
},
deactivate: function() {
return this.doAction('deactivate');
},
edit: function() {
this.transitionToRoute('service.edit', this.get('environmentId'), this.get('id'));
},
scaleUp: function() {
this.incrementProperty('scale');
this.saveScale();
},
scaleDown: function() {
this.decrementProperty('scale');
this.saveScale();
* Nanocloud is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General
* Public License
* along with this program. If not, see
* <http://www.gnu.org/licenses/>.
*/
import Ember from 'ember';
export default Ember.Controller.extend({
modelIsEmpty: Ember.computed.empty('items'),
sortableTableConfig: {
filteringIgnoreCase: true,
messageConfig: {
searchLabel: '',
searchPlaceholder: 'Search',
},
customIcons: {
'sort-asc': 'fa fa-caret-up',
'sort-desc': 'fa fa-caret-down',
caret: 'fa fa-minus',
'column-visible': 'fa fa-minus',
},