speciesOptions: Ember.computed('water', function() {
if ( this.get('water') === 'river' || this.get('water') === 'stillwater' ) {
return Ember.ArrayProxy.create({ content: freshwaterSpecies });
} else {
return Ember.ArrayProxy.create({ content: saltwaterSpecies });
}
}),
queryOptions: function(query, deferred) {
if (alreadyLoadedOnce) {
deferred.resolve({data: Ember.ArrayProxy.create({ content: moreContent }), more: false});
} else {
alreadyLoadedOnce = true;
deferred.resolve({data: Ember.ArrayProxy.create({ content: firstContent }), more: true});
}
}
test('history filtering', function() {
expect(2);
var component = this.subject();
var history = Ember.ArrayProxy.create({
content: [
Ember.Object.create({
name: 'HISTORY',
status: 1
}),
Ember.Object.create({
name: '1HISTORY',
status: 2
})
]
});
Ember.run(function() {
component.set('history', history);
});
equal(component.get('model.length'), 2, 'No filters applied we have 2 models');
Ember.run(function() {
component.filterBy('name', 'HISTORY', true);
});
equal(component.get('model.length'), 1, 'Filter by name we have 1 filtered model');
});
test('interval duration is set correctly', function () {
expect(2);
var component = this.subject();
var history = Ember.ArrayProxy.create({ content: [
Ember.Object.create({
duration: 20
}),
Ember.Object.create({
duration: 300
})
]});
Ember.run(function() {
component.set('history', history);
});
var durationColumn = component.get('columns').find(function (column) {
return column.get('caption') === 'columns.duration';
});
equal(durationColumn.get('numberRange.min'), 20, 'Min value is set correctly');
equal(durationColumn.get('numberRange.max'), 300, 'Max value is set correctly');
});
test('date range is set correctly', function () {
expect(2);
var component = this.subject();
var min = parseInt(Date.now() / 1000) - (60 * 60 * 24 * 60);
var max = parseInt(Date.now() / 1000);
var history = Ember.ArrayProxy.create({ content: [
Ember.Object.create({
dateSubmittedTimestamp: min
}),
Ember.Object.create({
dateSubmittedTimestamp: max
})
]});
Ember.run(function() {
component.set('history', history);
});
var dateColumn = component.get('columns').find(function (column) {
return column.get('caption') === 'columns.date';
});
equal(dateColumn.get('dateRange.min'), min, 'Min date is set correctly');
equal(dateColumn.get('dateRange.max'), max, 'Max date is set correctly');
});
lookupTypeValues: function() {
var values = this.get('lookupTypeList.value');
if (!Ember.isEmpty(values)) {
values.sort(this._sortValues);
}
return Ember.ArrayProxy.create({ content: Ember.A(values) });
}.property('model.lookupType', 'lookupTypeList.value'),
_stream: function(query) {
if (!query) {
query = {};
}
var resourceEndpoint = this.get('resourceEndpoint');
var promise = new Ember.RSVP.Promise(function(resolve, reject) {
Ember.$.ajax({
dataType: 'json',
url: `${resourceEndpoint}/i/stream/json`,
async: true,
data: query,
success: function(data) {
return resolve(data);
},
error: function(jqXHR, textStatus, errorThrown ) {
console.error('errror>', jqXHR, textStatus, errorThrown);
reject(jqXHR.responseJSON);
}
});
});
return Ember.ArrayProxy.extend(Ember.PromiseProxyMixin).create({
promise: promise
});
},
branches: function() {
let repoId = this.get('repo.id'),
popupName = this.get('popupName');
if(popupName === 'status-images') {
let array = Ember.ArrayProxy.create({ content: [] }),
apiEndpoint = Config.apiEndpoint,
options = {};
array.set('isLoaded', false);
if (this.get('auth.signedIn')) {
options.headers = {
Authorization: "token " + (this.auth.token())
};
}
$.ajax(apiEndpoint + "/v3/repo/" + repoId + "/branches?limit=100", options).then(function(response) {
if(response.branches.length) {
array.pushObjects(response.branches.map((branch) => { return branch.name; }));
} else {
array.pushObject('master');
}
array.set('isLoaded', true);
});
return array;
} else {
// if status images popup is not open, don't fetch any branches
return [];
}
}.property('popupName', 'repo'),
init: function () {
this._super();
this.set('columns', Ember.ArrayProxy.create({ content: Ember.A([
Ember.Object.create({
caption: "columns.shortQuery",
property: 'shortQuery',
link: constants.namingConventions.subroutes.savedQuery
}),
Ember.Object.create({
caption: "columns.title",
property: 'title',
link: constants.namingConventions.subroutes.savedQuery
}),
Ember.Object.create({
caption: "columns.database",
property: 'dataBase',
link: constants.namingConventions.subroutes.savedQuery
}),
Ember.Object.create({
caption: "columns.owner",
property: 'owner',
link: constants.namingConventions.subroutes.savedQuery
})
])}));
},
arrangedContent: function() {
"use strict";
this.set('totalWeights', this.get('content.length'));
this.set('startRecord', (this.page - 1) * this.recordsPerPage);
this.set('totalPages', Math.ceil(this.get('totalWeights') /
this.recordsPerPage));
if(this.page < this.totalPages) {
this.set('nextDisabled', false);
} else {
this.set('nextDisabled', true);
}
if(this.page === 1) {
this.set('prevDisabled', true);
} else {
this.set('prevDisabled', false);
}
return Ember.ArrayProxy.createWithMixins(Ember.SortableMixin, {
content: this.get('model').toArray(),
sortProperties: this.get('sortProperties'),
sortAscending: this.get('sortAscending')
}).slice(this.startRecord, this.startRecord + this.recordsPerPage);
}.property('weight', 'page', 'totalPages', 'prevDisabled',
test('optionValuePath with ArrayProxy', function(assert) {
assert.expect(1);
var Klass, arrData, data, obj1, obj2;
Klass = Ember.Object.extend({
name: null,
value: null
});
obj1 = Klass.create({
name: 'reddit',
value: 1
});
obj2 = Klass.create({
name: 'red',
value: 2
});
data = [obj1, obj2];
arrData = Ember.ArrayProxy.create({
content: Ember.A(data)
});
select = this.subject({
content: arrData,
optionLabelPath: 'name',
optionValuePath: 'value'
});
Ember.run(function() {
select.set('value', 2);
});
assert.equal(obj2, select.get('selection'), 'The right selection is retrieved');
});
populateAssignments: function() {
const assignmentsFromGroups = this.get('assignmentsFromGroups.content')
const selectedStudent = this.get('selectedStudent')
const submissionStateMap = this.get('submissionStateMap')
const proxy = Ember.ArrayProxy.createWithMixins(Ember.SortableMixin, {content: []})
if (selectedStudent) {
assignmentsFromGroups.forEach(assignment => {
const submissionCriteria = {assignment_id: assignment.id, user_id: selectedStudent.id}
if (
!__guard__(
submissionStateMap != null
? submissionStateMap.getSubmissionState(submissionCriteria)
: undefined,
x => x.hideGrade
)
) {
return proxy.addObject(assignment)
}
})
} else {
proxy.addObjects(assignmentsFromGroups)
}
proxy.set('sortProperties', this.get('assignments.sortProperties'))
this.set('assignments', proxy)
}.observes('assignmentsFromGroups.isLoaded', 'selectedStudent'),
function sortFunc(items){
var sortProperties = ["name"];
items = Ember.ArrayProxy.extend(Ember.SortableMixin).create(items);
items.set('sortProperties', sortProperties);
items.set('sortAscending', true);
return items;
}
visualizationLabel: function() {
var visualization = this.get('model.visualization');
var array = Ember.ArrayProxy.create({content: this.visualizations});
var record = array.findBy('value', visualization);
return record ? record['label'] : '';
}.property('model.visualization'),
export default function (totalCount, initSize, getNextChunk) {
var ret = Ember.A(new Array(totalCount));
var promise = getNextChunk();
promise.then(function (data) {
ret = data;
});
var LazyArray = Ember.ArrayProxy.extend({
objectAt: function (index) {
var reloadValue = index + 11;
if (reloadValue >= ret.length) {
var loop = (reloadValue - ret.length) / 100 + 1;
while (loop > 0) {
getNextChunk().then(function (data) {
ret = ret.concat(data);
});
loop--;
}
}
return ret[index];
},
length: totalCount
});
return LazyArray.create({
content: Ember.A(new Array(totalCount))
});
}
myCommentItems: function() {
var name = this.get('auth.user.name');
return Ember.ArrayProxy.createWithMixins({
cont: this,
content: Ember.computed.filterProperty('cont.commentItems', 'comment.author', name)
});
}.property('auth.user.name'),
reallyAll: function(type) {
type = normalizeType(type);
var proxy = Ember.ArrayProxy.create({
content: this._group(type)
});
return proxy;
},
this.on('customSearch', function(term) {
assert.equal(term, 'Foo Bar');
return Ember.ArrayProxy.create({
content: Ember.A([
{name: 'Foo'},
{name: 'Bar'},
])
});
});
pushPermissions: function() {
var permissions;
permissions = Ember.ArrayProxy.create({
content: []
});
this.get('_rawPermissions').then((data) => {
return permissions.set('content', data.push);
});
return permissions;
}.property(),
test('Bug: Ember.ArrayProxy does not have the method sort', (assert) => {
const list = Ember.ArrayProxy.create({
content: Ember.A([{ bar: 3 }, { bar: 4 }, { bar: 1 }, { bar: 3 }])
});
const subject = Ember.Object.extend({
orderedFoos: orderBy('foos', 'bar')
}).create({ foos: list });
assert.deepEqual(subject.get('orderedFoos'), [
{ bar: 1 }, { bar: 3 }, { bar: 3 }, { bar: 4 }
]);
});
test('it handles arrays with computed property lengths', function(assert) {
let ap = Ember.ArrayProxy.extend({
content: emberArray([1, 2, 3]),
length: computed('content.[]', function() {
return this.get('content.length');
})
}).create();
let expectedResult = [[1], [2], [3]];
let result = chunk(1, ap);
assert.deepEqual(result, expectedResult, 'should return array of chunked arrays');
});
model: function(){
var modelData = [
Ember.Object.create().setProperties({date: "2014-08-01", count: 100}),
Ember.Object.create().setProperties({date: "2014-08-02", count: 150}),
Ember.Object.create().setProperties({date: "2014-08-03", count: 200})
];
return Ember.ArrayProxy.create({
content: Ember.A(modelData)
});
},
setSourceFilesIcons: Ember.on('init', function() {
var demoName = 'input-Icons';
var sourceFiles = Ember.ArrayProxy.create({
content: Ember.A([
{name: 'hbs', content: demoName + '.hbs'},
{name: 'controller', content: 'input-controller.js'}
])
});
this.set('sourceFilesIcons', sourceFiles);
}),
test('removes the class "empty" when the cart is not empty', function(assert) {
let component = this.subject();
let cart = Ember.ArrayProxy.create({
content: Ember.A(),
counter: 1
});
set(component, 'cart', cart);
this.render();
assert.ok(!this.$().hasClass('cart-empty'));
});
test('Test filtered content using array proxy', function(assert) {
assert.expect(2);
var data = Ember.ArrayProxy.create({
content: Ember.A(['red', 'reddit', 'green', 'blue'])
});
select = this.subject({
content: data
});
select.set('query', 're');
assert.equal(select.get('filteredContent')[0], 'red');
assert.equal(select.get('filteredContent')[1], 'reddit');
});
lookupTypeValues: computed('model.lookupType', 'lookupTypeList.value.[]', function() {
let lookupType = this.get('model.lookupType');
let values = this.get('lookupTypeList.value');
if (!Ember.isEmpty(values)) {
values.sort(this._sortValues);
values = values.map((value) => {
return {
canModify: this._canModifyValue(value, lookupType),
value
};
});
}
return Ember.ArrayProxy.create({ content: Ember.A(values) });
}),
setSourceFiles: function() {
var demoName = this.get('demoName');
var sourceFiles = Ember.ArrayProxy.create({
content: [
{name: 'hbs', content: demoName + '-index.hbs'},
{name: 'controller', content: demoName + '-controller.js'},
{name: 'route', content: demoName + '-route.js'},
{name: 'css', content: demoName + '-style.css'}
]
});
this.set('sourceFiles', sourceFiles);
}.on('init'),
test('Set active tab on init', function() {
expect(2);
var tabs = Ember.ArrayProxy.create({content: Ember.A([
Ember.Object.create(),
Ember.Object.create(),
Ember.Object.create({ active: true })
])});
var component = this.subject({ tabs: tabs });
ok(!component.get('tabs.firstObject.active'), 'First tab is not active');
ok(component.get('tabs.lastObject.active'), 'Last tab is active');
});
tryPerson: function() {
var result = Ember.ArrayProxy.create({content: []});
$.ajax({
url: 'https://api.github.com/users/' + this.get('id') + '/repos',
type: 'GET',
success: (data) => {
this.set('repositories', data);
},
error: function() {
}
});
return result;
},
test('First tab active by default', function() {
expect(2);
var tabs = Ember.ArrayProxy.create({content: Ember.A([
Ember.Object.create(),
Ember.Object.create()
])});
var component = this.subject({ tabs: tabs });
var $component = this.$();
ok(component.get('tabs.firstObject.active'), 'First tab is active');
ok(!component.get('tabs.lastObject.active'), 'Second tab is not active');
});