export default Ember.Component.extend({
didInsertElement() {
let todos = this.get('todos');
if (todos.get('length') > 0 && todos.isEvery('complete', true)) {
this.set('allAreDone', true);
} else {
this.set('allAreDone', false);
}
},
remaining: Ember.computed('*****@*****.**', function() {
let todos = this.get('todos');
return todos.filterBy('complete', false).get('length');
}),
inflection: Ember.computed('remaining', function() {
var remaining = this.get('remaining');
return (remaining === 1) ? 'item' : 'items';
}),
completed: Ember.computed('*****@*****.**', function() {
var todos = this.get('todos');
return todos.filterBy('complete', true).get('length');
}),
hasCompleted: Ember.computed('completed', function() {
return this.get('completed') > 0;
}),
actions: {
clearCompleted() {
let completed = this.get('todos').filterBy('complete', true);
completed.forEach((todo) => {
todo.destroyRecord();
});
},
toggleAll(completeValue) {
this.set("allAreDone", completeValue);
let todos = this.get('todos');
todos.forEach((todo) => {
todo.set('complete', completeValue);
});
}
}
});
import Ember from 'ember';
const {computed} = Ember;
export default Ember.Component.extend({
i18n: Ember.inject.service(),
level: computed('entity', 'i18n.locale', function() {
return this.get('i18n').t(`location.model.${this.get('entity.level')}`);
}),
actions: {
closeDrawer() {
this.set('isOpen', false);
}
}
});
let IronSelector = Ember.Component.extend({
attributeBindings: [
'selected',
'role',
'attrForSelected',
'multi'
],
selectedItem: computed({
get() {},
set(key, value) {
let items = this.get('items');
let idx = -1;
if (items) {
idx = this.get('items').indexOf(value);
}
if (this.getSelectedIndex() !== idx && idx !== -1) {
this.set('selected', idx);
}
return value;
}
}),
getSelectedIndex() {
let el = this.element;
if (el) {
return typeof el.selected === 'number' ?
el.selected :
el.indexOf(el.selectedItem);
} else {
return -1;
}
},
didInsertElement() {
this._super(...arguments);
this.$().on('iron-select', () => {
let el = this.element;
let items = this.get('items');
if (items) {
this.set('selectedItem', items[this.getSelectedIndex()]);
} else {
this.set('selectedItem', el.selected);
}
});
// initial selection
let selectedItem = this.get('selectedItem');
if (selectedItem) {
let items = this.get('items');
if (items) {
this.element.select(selectedItem === 'number' ?
selectedItem :
items.indexOf(selectedItem));
} else {
this.element.select(selectedItem === 'number' ?
selectedItem :
this.element.items.indexOf(selectedItem));
}
}
}
});
export default Ember.Component.extend({
layoutName: 'components/user/notification-grid',
classNames: ['notification-grid'],
methods: [
{ name: 'alert', icon: 'bell', label: 'Alert' },
{ name: 'email', icon: 'envelope-o', label: 'Email' }
],
didInsertElement: function() {
var component = this;
this.$('thead .toggle-group').bind('mouseenter mouseleave', function(e) {
var i = parseInt($(this).index()) + 1;
component.$('table').find('td:nth-child('+i+')').toggleClass('highlighted', e.type === 'mouseenter');
});
this.$('tbody .toggle-group').bind('mouseenter mouseleave', function(e) {
$(this).parent().find('td').toggleClass('highlighted', e.type === 'mouseenter');
});
},
preferenceKey: function(type, method) {
return 'notify_'+type+'_'+method;
},
grid: Ember.computed('methods', 'notificationTypes', function() {
var grid = [];
var component = this;
var notificationTypes = this.get('notificationTypes');
var methods = this.get('methods');
var user = this.get('user');
notificationTypes.forEach(function(type) {
var row = Ember.Object.create({
type: type,
label: type.label,
cells: []
});
methods.forEach(function(method) {
var preferenceKey = 'preferences.'+component.preferenceKey(type.name, method.name);
var cell = Ember.Object.create({
type: type,
method: method,
enabled: !!user.get(preferenceKey),
loading: false,
disabled: typeof user.get(preferenceKey) == 'undefined'
});
cell.set('save', function(value, component) {
cell.set('loading', true);
user.set(preferenceKey, value).save().then(function() {
cell.set('loading', false);
});
});
row.get('cells').pushObject(cell);
});
grid.pushObject(row);
});
return grid;
}),
toggleCells: function(cells) {
var enabled = !cells[0].get('enabled');
var user = this.get('user');
var component = this;
cells.forEach(function(cell) {
if (!cell.get('disabled')) {
cell.set('loading', true);
cell.set('enabled', enabled);
user.set('preferences.'+component.preferenceKey(cell.get('type.name'), cell.get('method.name')), enabled);
}
});
user.save().then(function() {
cells.forEach(function(cell) {
cell.set('loading', false);
})
});
},
actions: {
toggleMethod: function(method) {
var grid = this.get('grid');
var component = this;
var cells = [];
grid.forEach(function(row) {
row.get('cells').some(function(cell) {
if (cell.get('method') === method) {
cells.pushObject(cell);
return true;
}
});
});
component.toggleCells(cells);
},
toggleType: function(type) {
var grid = this.get('grid');
var component = this;
grid.some(function(row) {
if (row.get('type') === type) {
component.toggleCells(row.get('cells'));
return true;
}
});
}
}
});
export default Ember.Component.extend({
store: Ember.inject.service(),
logDrain: null,
sendError(e, message) {
message = Ember.get(e, 'responseJSON.message') || message;
this.sendAction('failedAction', message);
},
actions: {
restart(){
let message = `Restarting ${this.logDrain.get('handle')}...`;
let errorMessage = `There was an error restarting ${this.logDrain.get('handle')}.`;
let component = this;
var op = this.get('store').createRecord('operation', {
type: 'configure',
logDrain: this.logDrain
});
op.save().then(() => {
component.logDrain.set('status', 'provisioning');
component.logDrain.save().then(() => {
component.sendAction('completedAction', message);
}).catch( (e) => { component.sendError(e, errorMessage); });
}).catch( (e) => { component.sendError(e, errorMessage); });
},
deprovision(){
// Confirm...
let confirmMsg = `\nDeprovisioning will remove ${this.logDrain.get('handle')} and CANNOT be undone.\n\n`;
confirmMsg += 'Are you sure you want to continue?\n';
if (!confirm(confirmMsg)) { return false; }
let message = `Deprovisioning ${this.logDrain.get('handle')}...`;
let errorMessage = `There was an error deprovisioning ${this.logDrain.get('handle')}.`;
let component = this;
let logDrain = this.logDrain; // Keep a ref for the run later
var op = this.get('store').createRecord('operation', {
type: 'deprovision',
logDrain: logDrain
});
op.save().then(() => {
component.sendAction('completedAction', message);
logDrain.set('status', 'deprovisioning');
}).catch( (e) => { component.sendError(e, errorMessage); });
}
}
});
import Ember from 'ember';
export default Ember.Component.extend({
tagName: "input",
_initializeKnob: function() {
var _this = this;
this.$().knob({
angleOffset: -125,
angleArc: 250,
step: 1,
width: this.get("size"),
height: this.get("size"),
min: 10,
readOnly: this.get("readOnly"),
max: 26,
format: function (d) { var f = (d * 1.8) + 32; return parseInt(f) + "°F"; },
fgColor: this.get("color"),
displayInput: true,
change: function (newValue) { _this.set("value", newValue); },
}).val(this.get("value"));
}.on("didInsertElement"),
_valueChanged: function () {
this.$().val(this.get("value")).trigger("change");
}.observes("value")
});
export default Ember.Component.extend({
spinner : Ember.inject.service(),
timer: 2000,
types: [{
id : "circles",
label : "Cirlces"
},{
id : "pulse",
label : "Pulse"
},{
id : "fading-circle",
label : "Fading Circles"
},{
id : "wave",
label : "Wave"
},{
id : "double-bounce",
label : "Double Bounce"
},{
id : "rotating-plane",
label : "Rotating Plane"
},{
id : "folding-cube",
label : "Folding Cube"
},{
id : "wandering-cubes",
label : "Wandering Cubes"
},{
id : "chasing-dots",
label : "Chasing Dots"
},{
id : "three-bounce",
label : "Three Bounce"
},
{
id : "three-bounce-horizontal",
label : "Three Bounce Horizontal"
},{
id : "cube-grid",
label : "Cube Grid"
}],
actions: {
showBoxSpinner() {
let spinner = this.get("spinner");
let timer = this.get("timer");
let type = $(".box-select").val();
spinner.setAnimation("box", type);
spinner.show("box", {
timeout : timer
});
}
}
});
import Ember from 'ember';
export default Ember.Component.extend({
tagName: 'span',
classNames: ['octicon'],
classNameBindings: ['icon']
});
export default Ember.Component.extend({
init() {
this._super(...arguments);
this.renderFilters();
this.resetActiveFilter();
this.populateFields();
this.populateOperators();
},
// Initialize options for the dropdown menus
populateOperators() {
const options = this.get('operators').map(op => ({ operator: op }));
this.set('operatorOptions', options);
},
populateFields() {
const meta = this.get('metadata');
const fieldOptions = meta.columns.map((col) => {
const name = col.field_name;
return { computerName: name, humanName: humanizeName(name) };
});
this.set('fieldOptions', fieldOptions);
},
operators: ['=', '>', '>=', '<', '<=', '!=', 'LIKE', 'IN'],
// Take in filters as JSON
// And operate on them internally as JS objects.
// When user adds or removes a filter,
// mutate the passed in JSON accordingly.
filtersChanged: Ember.observer('filters', function () {
this.renderFilters();
}),
renderFilters() {
const filterJSON = this.get('filters');
this.set('filterHashes', JSON.parse(filterJSON));
},
mutateFilterJSON() {
const hashes = this.get('filterHashes');
this.set('filters', JSON.stringify(hashes));
},
actions: {
madeSelection(fieldName, value) {
this.set(fieldName, value);
},
submit() {
this.get('filterHashes').pushObject(this.get('activeFilter'));
this.mutateFilterJSON();
this.resetActiveFilter();
},
removeFilter(index) {
this.set('filterHashes', this.get('filterHashes').removeAt(index));
this.mutateFilterJSON();
},
},
// Manage the filter the user is currently editing
notComplete: Ember.computed('activeFilter.field',
'activeFilter.op',
'activeFilter.val',
function () {
const filter = this.get('activeFilter');
return !(filter.field && filter.op && filter.val);
}),
makeNewFilter() {
return Ember.Object.create({
field: null,
op: null,
val: null,
});
},
resetActiveFilter() {
this.set('activeFilter', this.makeNewFilter());
},
});
import Ember from 'ember';
export default Ember.Component.extend({
tagName: "span",
actions: {
saveNote() {
this.get('note').save();
},
closeNote() {
this.sendAction('close');
}
}
});
import Ember from 'ember';
export default Ember.Component.extend({
addCategory: false,
actions: {
save(){
var params = {
name: this.get('name'),
};
// console.log(params);
this.set('addCategory', false);
this.sendAction('save', params);
},
showForm() {
this.set('addCategory', true);
}
}
});
import Ember from "ember";
export default Ember.Component.extend({
foo: 1
});
export default Ember.Component.extend({
tagName: 'form',
classNameBindings: ['layoutClass'],
ariaRole: 'form',
/**
* Bootstrap form class name (computed)
*
* @property layoutClass
* @type string
* @readonly
* @protected
*
*/
layoutClass: Ember.computed('formLayout', function() {
var layout = this.get('formLayout');
return layout === 'vertical' ? 'form' : 'form-' + layout;
}),
/**
* Set a model that this form should represent. This serves several purposes:
*
* * child `Components.FormElement`s can access and bind to this model by their `property`
* * when the model supports validation by using the [ember-validations](https://github.com/dockyard/ember-validations) mixin,
* child `Components.FormElement`s will look at the validation information of their `property` and render their form group accordingly.
* Moreover the form's `submit` event handler will validate the model and deny submitting if the model is not validated successfully.
*
* @property model
* @type Ember.Object
* @public
*/
model: null,
/**
* Set the layout of the form to either "vertical", "horizontal" or "inline". See http://getbootstrap.com/css/#forms-inline and http://getbootstrap.com/css/#forms-horizontal
*
* @property formLayout
* @type string
* @public
*/
formLayout: 'vertical',
/**
* Check if the `model` has a validate method, i.e. supports validation by using [ember-validations](https://github.com/dockyard/ember-validations)
*
* @property hasValidator
* @type boolean
* @readonly
* @protected
*/
hasValidator: Ember.computed.notEmpty('model.validate'),
/**
* The Bootstrap grid class for form labels. This is used by the `Components.FormElement` class as a default for the
* whole form.
*
* @property horizontalLabelGridClass
* @type string
* @default 'col-md-4'
* @public
*/
horizontalLabelGridClass: 'col-md-4',
/**
* An array of `Components.FormElement`s that are children of this form.
*
* @property childFormElements
* @type Array
* @readonly
* @protected
*/
childFormElements: Ember.computed.filter('childViews', function(view) {
return view instanceof FormElement;
}),
/**
* Submit handler that will send the default action ("action") to the controller when submitting the form.
*
* If there is a supplied `model` that supports validation (`hasValidator`) the model will be validated before, and
* only if validation is successful the default action will be sent. Otherwise an "invalid" action will be sent, and
* all the `showValidation` property of all child `Components.FormElement`s will be set to true, so error state and
* messages will be shown automatically.
*
* @event submit
*/
submit: function(e) {
var that = this;
if (e) {
e.preventDefault();
}
if (!this.get('hasValidator')) {
return this.sendAction();
} else {
return this
.get('model')
.validate()
.then(function() {
if (that.get('model.isValid')) {
return that.sendAction();
}
})
.catch(function(){
that.get('childFormElements').setEach('showValidation', true);
return that.sendAction('invalid');
});
}
}
});
import Ember from 'ember';
export default Ember.Component.extend({
cvsList: null,
heading: null
});
import Ember from 'ember';
export default Ember.Component.extend({
classNameBindings: ['isActive:active'],
// 将外部不断改变的元素传递进来
activeTab: '',
tab: '',
isActive: function() {
return this.get('tab') === this.get('activeTab');
}.property('activeTab')
});
import Ember from 'ember';
import layout from '../templates/components/ember-modal-close-button';
export default Ember.Component.extend({
classNames: ['ember-modal-close-button'],
layout,
onClick: null,
tagName: 'button',
click() {
this.sendAction('onClick');
},
});
export default Ember.Component.extend({
tagName: "span",
icon_type: function(){
var type;
switch(this.get("location.type")){
case "Airport":
type = "airplane";
break;
case "Port":
type = "boat";
break;
case "Airbnb":
type = "airbnb";
break;
case "Hotel":
type= "hotel";
break;
default:
type = "pin";
};
return type;
}.property("location.type"),
icon_name: function(){
return config.pathPrefix+"images/icon_"+this.get("icon_type")+"@2x.png";
}.property("icon_type"),
icon_name_active: function(){
return config.pathPrefix+"images/icon_"+this.get("icon_type")+"*****@*****.**";
}.property("icon_type"),
});
var MdButtonComponent = Ember.Component.extend(RipplesMixin, {
tagName: 'button',
classNames: ['md-button'],
attributeBindings: ['disabled', 'href', 'style', 'type'],
setupRipples: function() {
if (this.get('mdNoInk')) {
return;
}
this.get('rippleService').attachButtonBehavior(this.$());
}.on('didInsertElement'),
buttonClassNames: function() {
var classNames = '';
this.get('classNames').forEach((cn) => {
classNames = classNames + " " + (cn);
});
return classNames;
}.property('classNames'),
click: function() {
this.sendAction();
}
});
import Ember from 'ember';
export default Ember.Component.extend({
showSubCategories: false,
actions: {
showSubCategories() {
this.get('showSubCategories') ? this.set('showSubCategories', false) : this.set('showSubCategories', true);
}
}
});
import Ember from 'ember';
import WindowMixin from 'ember-cli-smart-tv/mixins/frame/window-frame';
export default Ember.Component.extend(WindowMixin, {
classNameBindings: ['isHover:hover-window-frame']
});
export default Em.Component.extend({
isChatting: false,
isReadyToChat: false,
userName: null,
chateeUserName: null,
socket: null,
classNames: ['centered-form'],
message: null,
historyMessage: null,
endOfChat: false,
actions: {
readyToChat: function (userName) {
this.setProperties({
'isReadyToChat': true,
'userName': userName
});
this.get('socket').emit('newUser', userName);
},
sendMessage: function(message){
this.set('historyMessage', {message: message, userName: '******', className: 'user-row'});
this.get('socket').emit('message', message);
}
},
didInsertElement: function(){
var socket = io(), self = this;
this.set('socket', socket);
socket
.on('startChat', function(chateeUserName){
self.setProperties({
'isChatting': true,
'chateeUserName': chateeUserName
});
})
.on('message', function(message){
self.setProperties({
'message': message,
'historyMessage': {message: message, userName: self.get('chateeUserName'), className: 'chatee-row'}
});
})
.on('userDisconnected', function(){
self.setProperties({
'historyMessage': {userName: self.get('chateeUserName'), className: 'dc-row', isLeaveMsg: true},
endOfChat: true
});
});
}
});
import Ember from 'ember';
export default Ember.Component.extend({
tagName: 'div',
classNames: ['gears'],
visibility: Ember.inject.service('visible'),
isVisible: Ember.computed.alias('visibility.isVisible'),
_startTimer: Ember.on('didInsertElement', function () {
var _this = this;
this._visibleTimer = Ember.run.later(this, function () {
_this._visibleTimer = null;
_this.set('isVisible', true);
}, 5000);
}),
_endTimer: Ember.on('willDestroyElement', function () {
if (this._visibleTimer) {
Ember.run.cancel(this, this._visibleTimer);
}
})
});
import Ember from "ember";
import layout from 'liquid-fire/templates/components/liquid-with';
var LiquidWith = Ember.Component.extend({
layout,
name: 'liquid-with',
positionalParams: ['value'], // needed for Ember 1.13.[0-5] and 2.0.0-beta.[1-3] support
tagName: '',
iAmDeprecated: Ember.on('init', function() {
Ember.deprecate("liquid-with is deprecated, use liquid-bind instead -- it accepts a block now.");
})
});
LiquidWith.reopenClass({
positionalParams: ['value']
});
export default LiquidWith;
export default Ember.Component.extend({
isStudentFormEditing: false,
store: Ember.inject.service(),
selectedResidency: null,
selectedGender: null,
selectedAcademicLoad: null,
selectedDate: null,
routing: Ember.inject.service('-routing'),
residencyModel: Ember.computed(function(){
var self = this;
this.get('store').findAll('residency').then(function(records){
self.set('selectedResidency', records.get('firstObject').get('id'));
});
return this.get('store').findAll('residency');
}),
genderModel: Ember.computed(function(){
var self = this;
this.get('store').findAll('gender').then(function(records){
self.set('selectedGender', records.get('firstObject').get('id'));
});
return this.get('store').findAll('gender');
}),
academicLoadModel: Ember.computed(function(){
var self = this;
this.get('store').findAll('academicLoad').then(function(records){
self.set('selectedAcademicLoad', records.get('firstObject').get('id'));
});
return this.get('store').findAll('academicLoad');
}),
actions: {
saveStudent () {
var myStore = this.get('store');
var chosenResidency = myStore.peekRecord('residency', this.get('selectedResidency'));
var chosenGender = myStore.peekRecord('gender', this.get('selectedGender'));
var chosenAcademicLoad = myStore.peekRecord('academicLoad', this.get('selectedAcademicLoad'));
var newStudent = myStore.createRecord('student', {
number: this.get('number'),
firstName: this.get('firstName'),
lastName: this.get('lastName'),
DOB: new Date(this.get('selectedDate')),
residency: chosenResidency, //***
gender: chosenGender,
academicLoad: chosenAcademicLoad
});
// we can use this line instead of the one with the *** above
//chosenResidency.get('students').pushObject(newStudent);
var self = this;
newStudent.save().then(() => {
self.set('isStudentFormEditing', false);
});
this.get('routing').transitionTo('view-students' );
},
assignDate (date){
this.set('selectedDate', date);
},
selectResidency (residency){
this.set('selectedResidency', residency);
},
selectGender (gender){
this.set('selectedGender', gender);
},
selectAcademicLoad (academicLoad){
this.set('selectedAcademicLoad', academicLoad);
},
addNewStudent () {
var datestring = (new Date()).toISOString().substring(0, 10);
this.set('selectedDate', datestring);
this.set('isStudentFormEditing', true);
},
cancel () {
this.set('isStudentFormEditing', false);
}
}
});
import Ember from 'ember';
export default Ember.Component.extend({
isActive: Ember.computed('target', 'current', function () {
return this.get('target') === this.get('current');
}),
desc: Ember.computed('type', function () {
return this.get('type') === 'desc';
})
});
import Ember from 'ember';
export default Ember.Component.extend({
bookmarkQuestion: Ember.inject.service(),
});
import Ember from 'ember';
export default Ember.Component.extend({
addNewComment: false,
actions: {
commentFormShow() {
this.set('addNewComment', true);
},
saveComment() {
var params = {
name: this.get('name') ? this.get('name'): "",
content: this.get('content') ? this.get('content'): "",
product: this.get('product')
};
this.set('addNewComment', false);
this.sendAction('saveCommentB', params);
}
}
});
import Ember from 'ember';
export default Ember.Component.extend({
showReviewForm: false,
actions:{
reviewFormShow(){
this.set('showReviewForm', true);
},
cancelSave() {
this.set('showReviewForm', false);
},
saveReview() {
var params = {
author: this.get('author'),
content: this.get('content'),
rating: parseFloat(this.get('rating')),
rental: this.get('rental')
};
this.set('showReviewForm', false);
this.sendAction('saveReviewToRental', params);
}
}
});
import Ember from 'ember';
import layout from '../templates/components/notification-container';
export default Ember.Component.extend({
layout: layout,
classNames: ['c-notification__container'],
classNameBindings: [
'computedPosition'
],
computedPosition: Ember.computed('position', function() {
if (this.get('position')) {
return `c-notification__container--${this.get('position')}`;
}
return `c-notification__container--top`;
})
});
import Ember from 'ember';
export default Ember.Component.extend({
shoppingCart: Ember.inject.service(),
actions: {
addToCart(product) {
var productQuantity = this.get('productQuantity') || 1;
this.get('shoppingCart').add(product, productQuantity);
}
}
});