import Ember from "ember";
import TerrainType from "../models/terrain-type";
import TerrainProperties from "../models/terrain-properties";
export default Ember.Object.extend({
init:function(){
this._super();
var a = Ember.A();
var type=this.get('type');
for(var i = 0;i< type.length;i++)
{
a.pushObject(TerrainType.create(type[i]));
}
this.set('type',a);
},
type:Ember.A(),
name:null,
color:null,
number:null,
label:function(){
var all = this.get('controller.showOne');
var col = this.get('type');
var arr = [];
for(var i = 0;i < col.length;i++){
var c;
c = col[i].get('name');
if(all && c !== this.get('controller.selectedColor')){
continue;
}
var prop = TerrainProperties.get(c);
if(prop){
arr.push(prop);
get,
set
} = Ember;
const {
htmlSafe
} = Ember.String;
const MASONRY_OPTION_KEYS = Ember.A([
'containerStyle',
'columnWidth',
'gutter',
'hiddenStyle',
'isFitWidth',
'isInitLayout',
'isOriginLeft',
'isOriginTop',
'isResizeBound',
'itemSelector',
'stamp',
'transitionDuration',
'visibleStyle'
]);
export default Component.extend({
layout,
classNames: ['masonry-grid'],
// masonry default options
// overriding the default `isInitLayout` value allows us to attach an event for
// `layoutComplete` before the first render
return makeArray(locales).some((locale) => {
return adapter.has(locale, key);
});
},
getLocalesByTranslations() {
return Object.keys(requirejs.entries).reduce((translations, module) => {
const match = module.match(TRANSLATION_PATH_CAPTURE);
if (match) {
translations.addObject(match[1]);
}
return translations;
}, Ember.A());
},
/**
* A utility method for registering CLDR data for
* intl-messageformat and intl-relativeformat. This data is derived
* from formatjs-extract-cldr-data
*
* @method addLocaleData
* @param {Object} locale data
* @public
*/
addLocaleData(data) {
IntlMessageFormat.__addLocaleData(data);
IntlRelativeFormat.__addLocaleData(data);
},
persistedSelection: Ember.computed(function() {
return Ember.A();
}),
import Ember from 'ember';
import Orderline from 'playful/models/orderline';
import _ from 'lodash';
import AudioFileModel from 'playful/models/audio-file';
import ImageFileModel from 'playful/models/image-file';
export default Orderline.extend({
audioFiles: Ember.A(),
imageFiles: Ember.A(),
releaseMatches: Ember.A(),
store: null,
routeMap: {
'import.index': 'import.audio.tag',
'import.audio.tag': 'import.selectShare'
},
nextRoute: function(currentRoute){
return this.get('routeMap')[currentRoute];
},
scansDidChange: function(){
var store = this.get('store'),
audioScans = _.filter(this.get('scans'), function(s){ return s.get('isAudio'); }),
imageScans = _.filter(this.get('scans'), function(s){ return s.get('isImage'); }),
audioFiles = _.map(audioScans, function(s){ return AudioFileModel.fromScan(s, store); }),
imageFiles = _.map(imageScans, function(s){ return ImageFileModel.fromScan(s, store); });
this.set('audioFiles', Ember.A(audioFiles));
this.set('imageFiles', Ember.A(imageFiles));
}.observes('scans').on('init')
});
function setupApp() {
App = Application.create();
App.setupForTesting();
App.injectTestHelpers();
App.Router.map(function() {
this.route('simple');
this.route('comments', { resetNamespace: true }, function() {});
this.route('posts', { resetNamespace: true });
});
App.ApplicationRoute = Route.extend({
model() {
return EmberObject.create({
toString() {
return 'Application model';
}
});
}
});
App.SimpleRoute = Route.extend({
model() {
return EmberObject.create({
toString() {
return 'Simple Model';
}
});
}
});
App.CommentsIndexRoute = Route.extend({
model() {
return Ember.A(['first comment', 'second comment', 'third comment']);
}
});
App.PostsRoute = Route.extend({
model() {
return 'String as model';
}
});
App.ApplicationController = Controller.extend();
App.ApplicationController.reopenClass({
toString() {
return 'App.ApplicationController';
}
});
App.SimpleController = Controller.extend();
App.SimpleController.reopenClass({
toString() {
return 'App.SimpleController';
}
});
setTemplate('application', '{{outlet}}');
setTemplate('simple', 'Simple {{input class="simple-input"}}');
setTemplate('comments/index', '{{#each}}{{this}}{{/each}}');
setTemplate('posts', 'Posts');
}
userIndividualNames: Ember.computed(function() {
return Ember.A();
}),
Ember.run(function() {
component.set('content', Ember.A(['item 1', 'item 2', 'item 3', 'item 4']));
component.set('on-init', 'externalAction');
component.set('targetObject', targetObject);
});
Ember.run(function() {
component.set('content', Ember.A(['item 1', 'item 2', 'item 3']));
component.set('selection', 'item 2');
});
Ember.run(function() {
component.set('selection', Ember.A(['item 1', 'item 2', 'item 4']));
});
Ember.run(function() {
component.set('content', Ember.A(['item 1', 'item 2', 'item 3', 'item 4']));
component.set('selection', Ember.A(['item 2', 'item 3']));
component.set('multiple', true);
});
Ember.run(function() {
component.set('content', Ember.A(['item 1']));
});
Ember.run(function() {
resolve(Ember.A([yehuda, tom]));
});
options: Ember.computed(function() {
return Ember.A();
}),
import Ember from 'ember';
import FormGroup from 'ember-bootstrap/components/bs-form-group';
import Form from 'ember-bootstrap/components/bs-form';
const { computed } = Ember;
const nonTextFieldControlTypes = Ember.A([
'checkbox',
'select',
'textarea'
]);
/**
Sub class of `Components.FormGroup` that adds automatic form layout markup and form validation features.
### Form layout
The appropriate Bootstrap markup for the given `formLayout` and `controlType` is automatically generated to easily
create forms without coding the default Bootstrap form markup by hand:
```hbs
{{#bs-form formLayout="horizontal" action="submit"}}
{{bs-form-element controlType="email" label="Email" placeholder="Email" value=email}}
{{bs-form-element controlType="password" label="Password" placeholder="Password" value=password}}
{{bs-form-element controlType="checkbox" label="Remember me" value=rememberMe}}
{{bs-button defaultText="Submit" type="primary" buttonType="submit"}}
{{/bs-form}}
```
### Form validation
defaultValue: function defaultValue() {
return Ember.A();
}
assert(`All elements of a hasMany relationship must be instances of DS.Model, you passed ${Ember.inspect(records)}`, (function() {
return Ember.A(records).every((record) => record.hasOwnProperty('_internalModel') === true);
})());
daysArray.pushObject(paper);
currentDay.add(1, 'days');
}
this.groupByWeeks(daysArray);
},
/**
* groups days into week objects
*
* @private
* @method groupByWeeks
*/
groupByWeeks(completeArray) {
let grouped = Ember.A([]);
grouped.pushObject(completeArray.filterBy('weekNumber', 1));
grouped.pushObject(completeArray.filterBy('weekNumber', 2));
grouped.pushObject(completeArray.filterBy('weekNumber', 3));
grouped.pushObject(completeArray.filterBy('weekNumber', 4));
grouped.pushObject(completeArray.filterBy('weekNumber', 5));
grouped.pushObject(completeArray.filterBy('weekNumber', 6));
this.set('groupedArray', grouped);
},
/**
* puts days into week objects
*
* @private
for (var i = 0; i < setsLength; i++) {
var set = sets[i];
var keys = Ember.keys(set);
for (var j = 0; j < keys.length; j++) {
var key = keys[j];
output[key] = set[key];
}
}
return output;
}
function describeRule(rule) {
return `[liquid-fire rule ${rule.id}]`;
}
function highestPriority(rules) {
var best;
var bestScore = 0;
for (var i = 0; i < rules.length; i++) {
var rule = rules[i];
var score = rules[i].constraints.length;
if (!best || score > bestScore || (score === bestScore && rule.id > best.id)) {
best = rule;
bestScore = score;
}
}
return best;
}
var constrainableKeys = Ember.A(Ember.keys(constrainables));
var tests = Ember.A([{
testName : "Basic Tests",
columnData : {
name : "test1",
validation : {
validations : [
{type : 0, invalidMessage : "Cant be empty"},
{type : 1, regex : "^[a-z]*$", regexFlags : "i", negate : true, invalidMessage : "Failed Regex"},
],
},
},
record : {},
validations : Ember.A([{
value : null,
result : true,
message : "Cant be empty",
}, {
value : "",
result : true,
message : "Cant be empty",
}, {
value : 123,
result : true,
message : "Failed Regex",
}, {
value : "a.b",
result : true,
message : "Failed Regex",
}, {
value : "abc",
result : false,
message : "",
}, {
value : "ABC",
result : false,
message : "",
}]),
}]),
voucherBarcodings: Ember.computed(function() {
return Ember.A();
}),
return true;
}),
noVideoHardware: computed('canShareAudio', 'canShareVideo', function () {
return !this.get('canShareAudio') && !this.get('canShareVideo');
}),
callCapable: computed('noVideoHardware', function () {
if (!webrtcsupport.support || !webrtcsupport.supportWebAudio) {
return false;
}
return !this.get('noVideoHardware');
}),
outputDeviceList: Ember.A(),
resolutionList: Ember.A(),
canShareScreen: false,
// Returns a promise which resolves when all devices have been enumerated and loaded
init () {
this._super(...arguments);
run.next(this, function () {
this.enumerateDevices();
this.enumerateResolutions();
});
this.set('canShareScreen', webrtcsupport.supportScreenSharing);
this.lookup = this.lookup || ((key) => key);
},
rangeSelection: Ember.computed(function() {
return Ember.A();
}),
setup: function() {
this.set('content', Em.A());
}.on('init'),
tabPanels: Ember.computed(function() {
return Ember.A();
}).readOnly(),
if (interval > max) {
interval = max;
}
}
}
});
return request;
},
handleBacklog(backlog) {
const that = this;
Object.keys(backlog.Channels).forEach(function(key) {
channels[key] = backlog.Channels[key];
});
Ember.A(backlog.Messages).forEach(function(message) {
that.handleMessage(message.Channel, message.Payload);
});
},
handleMessage(channel, event) {
if (isNone(event) || isNone(channel)) {
return;
}
this.trigger(channel, event);
}
});
import Ember from 'ember';
export default Ember.Controller.extend({
breakdowns: Ember.A([]),
});
content: Ember.computed(function() {
return Ember.A();
}),
import Ember from 'ember';
export default Ember.Component.extend({
selectedItems : Ember.A(),
columns :
[
{
"component": "ember-models-table-select-row-checkbox",
"useFilter": false,
"mayBeHidden": false,
"componentForSortCell": "ember-models-table-select-all-rows-checkbox"
},
{
"title" : "Id",
"propertyName": "id"
},
{
"title" : "Spider",
"propertyName": "spider"
},
{
"title" : "Start time",
"propertyName": "start_time",
"sortPrecedence" : 1 ,
"sortDirection" : "desc"
},
return computed(function w(key, value) {
if (arguments.length > 1) {
value = toArray(value);
}
return Ember.A(value || toArray(defaultValue));
});