this.get('/users', function ({users}, {queryParams}) {
let data = _doGlobalFilter(users, queryParams.globalSearch);
let filterBy = _getFilters(queryParams);
let useFilters = !!keys(filterBy).length;
data = useFilters ? _doFilter(data, filterBy) : data;
let json = this.serialize(data);
let pageSize = parseInt(queryParams.pageSize || 10, 10);
let page = parseInt(queryParams.page || 1, 10);
let startIndex = pageSize * (page - 1);
let itemsCount = json.data.length;
let pagesCount = Math.trunc(itemsCount / pageSize);
if (itemsCount % pageSize) {
pagesCount++;
}
let {sort} = queryParams;
if (sort) {
json.data = A(json.data).sortBy(`attributes.${dasherize(sort)}`);
}
if (queryParams.sortDirection === 'DESC') {
json.data = json.data.reverse();
}
json.data = json.data.slice(startIndex, startIndex + pageSize);
json.meta = {
itemsCount,
pagesCount
};
return json;
});
server.get('/ghost/api/v2/admin/slugs/:type/:slug/', function (request) {
expect(request.params.type).to.equal(type);
expect(request.params.slug).to.equal(slug);
return [
200,
{'Content-Type': 'application/json'},
JSON.stringify({slugs: [{slug: dasherize(slug)}]})
];
});
server.post('/posts', function ({posts, users, tags}) {
let attrs = this.normalizedRequestAttrs();
attrs.authors = extractAuthors(attrs, users);
attrs.tags = extractTags(attrs, tags);
if (isBlank(attrs.slug) && !isBlank(attrs.title)) {
attrs.slug = dasherize(attrs.title);
}
return posts.create(attrs);
});
namespaces.forEach(namespace => {
for (let key in namespace) {
if (!namespace.hasOwnProperty(key)) {
continue;
}
if (typeSuffixRegex.test(key)) {
let klass = namespace[key];
if (typeOf(klass) === 'class') {
types.push(dasherize(key.replace(typeSuffixRegex, '')));
}
}
}
});
namespaces.forEach(namespace => {
for (let key in namespace) {
if (!namespace.hasOwnProperty(key)) {
continue;
}
// Even though we will filter again in `getModelTypes`,
// we should not call `lookupFactory` on non-models
if (!this.detect(namespace[key])) {
continue;
}
let name = dasherize(key);
types.push(name);
}
});
test('Valid form submit', async function(assert) {
await visit('/');
for (let key in validInputValues) {
const selector = `[data-test-${dasherize(key)}]`;
const input = find(`${selector} input`);
assert.ok(input, `${selector} found`);
await fillIn(input, validInputValues[key]);
assert.dom(selector).hasClass('has-success');
}
await click('[data-test-sign-up]');
// assert.dom('[data-test-tomster]').exists();
assert.dom('.form .registered .icon-success').exists();
assert.dom('.form .registered h2.success').hasText('Success');
});
server.post('/posts', function ({posts, users}) {
let attrs = this.normalizedRequestAttrs();
let authors = [];
// NOTE: this is necessary so that ember-cli-mirage has a valid user
// schema object rather than a plain object
// TODO: should ember-cli-mirage be handling this automatically?
attrs.authors.forEach((author) => {
authors.push(users.find(author.id));
});
attrs.authors = authors;
if (isBlank(attrs.slug) && !isBlank(attrs.title)) {
attrs.slug = dasherize(attrs.title);
}
return posts.create(attrs);
});
export function createCustomResolver(registry) {
if (require.has('ember-native-dom-event-dispatcher')) {
// the raw value looked up by ember and these test helpers
registry['event_dispatcher:main'] = require('ember-native-dom-event-dispatcher').default;
// the normalized value looked up
registry['event-dispatcher:main'] = require('ember-native-dom-event-dispatcher').default;
}
var Resolver = Ember.DefaultResolver.extend({
registry: null,
resolve(fullName) {
return this.registry[fullName];
},
normalize(fullName) {
return dasherize(fullName);
},
});
return Resolver.create({ registry, namespace: {} });
}
test('serializeIntoHash uses payloadKeyFromModelName to normalize the payload root key', function(assert) {
let league = env.store.createRecord('home-planet', { name: 'Umber', id: '123' });
let json = {};
env.owner.register(
'serializer:home-planet',
DS.RESTSerializer.extend({
payloadKeyFromModelName(modelName) {
return dasherize(modelName);
},
})
);
let serializer = env.store.serializerFor('home-planet');
serializer.serializeIntoHash(json, HomePlanet, league._createSnapshot());
assert.deepEqual(json, {
'home-planet': {
name: 'Umber',
},
});
});
function test(assert, given, expected, description) {
assert.deepEqual(dasherize(given), expected, description);
if (ENV.EXTEND_PROTOTYPES.String) {
assert.deepEqual(given.dasherize(), expected, description);
}
}
Note: Requests coalescing rely on URL building strategy. So if you override `buildURL` in your app
`groupRecordsForFindMany` more likely should be overridden as well in order for coalescing to work.
@property coalesceFindRequests
@type {boolean}
*/
coalesceFindRequests: false,
findMany(store, type, ids, snapshots) {
let url = this.buildURL(type.modelName, ids, snapshots, 'findMany');
return this.ajax(url, 'GET', { data: { filter: { id: ids.join(',') } } });
},
pathForType(modelName) {
let dasherized = dasherize(modelName);
return pluralize(dasherized);
},
// TODO: Remove this once we have a better way to override HTTP verbs.
updateRecord(store, type, snapshot) {
let data = {};
let serializer = store.serializerFor(type.modelName);
serializer.serializeIntoHash(data, type, snapshot, { includeId: true });
let url = this.buildURL(type.modelName, snapshot.id, snapshot, 'updateRecord');
return this.ajax(url, 'PATCH', { data: data });
}
});
import { dasherize } from '@ember/string';
export default DS.JSONAPISerializer.extend({
keyForAttribute(attr, method) {
return dasherize(attr).toUpperCase();
}
});
```
@method keyForAttribute
@param {String} key
@param {String} method
@return {String} normalized key
*/
keyForAttribute(key, method) {
return dasherize(key);
},
/**
`keyForRelationship` can be used to define a custom key when
serializing and deserializing relationship properties.
By default `JSONAPISerializer` follows the format used on the examples of
http://jsonapi.org/format and uses dashes as word separators in
relationship properties.
This behaviour can be easily customized by extending this method.
Example
```app/serializers/post.js
import DS from 'ember-data';
modelClassName: computed('modelName', function() {
let modelName = this.get('modelName');
return modelName ? `${dasherize(modelName)}-model-input` : null;
}),
export function propertyNameToTitle(name) {
return capitalize(dasherize(name).replace(/-/g, ' '));
}
env.replaceContainerNormalize(key => dasherize(camelize(key)));
export default function setupStore(options) {
let container, registry, owner;
let env = {};
options = options || {};
if (Ember.Registry) {
registry = env.registry = new Ember.Registry();
owner = Owner.create({
__registry__: registry
});
container = env.container = registry.container({
owner: owner
});
owner.__container__ = container;
} else {
container = env.container = new Ember.Container();
registry = env.registry = container;
}
env.replaceContainerNormalize = function replaceContainerNormalize(fn) {
if (env.registry) {
env.registry.normalize = fn;
} else {
env.container.normalize = fn;
}
};
let adapter = env.adapter = (options.adapter || '-default');
delete options.adapter;
if (typeof adapter !== 'string') {
env.registry.register('adapter:-ember-data-test-custom', adapter);
adapter = '-ember-data-test-custom';
}
for (let prop in options) {
registry.register('model:' + dasherize(prop), options[prop]);
}
registry.register('service:store', DS.Store.extend({
adapter: adapter
}));
registry.optionsForType('serializer', { singleton: false });
registry.optionsForType('adapter', { singleton: false });
registry.register('adapter:-default', DS.Adapter);
registry.register('serializer:-default', DS.JSONAPISerializer);
registry.register('serializer:-json', DS.JSONSerializer);
registry.register('serializer:-rest', DS.RESTSerializer);
registry.register('adapter:-rest', DS.RESTAdapter);
registry.register('adapter:-json-api', DS.JSONAPIAdapter);
registry.injection('serializer', 'store', 'service:store');
env.store = container.lookup('service:store');
env.restSerializer = container.lookup('serializer:-rest');
env.restSerializer.store = env.store;
env.serializer = env.store.serializerFor('-default');
env.serializer.store = env.store;
env.adapter = env.store.get('defaultAdapter');
return env;
}
special: computed('name', function() {
if (!isEmpty(get(this, 'name')) && kSpecial.indexOf(get(this, 'name')) !== -1) {
return dasherize(get(this, 'name'));
}
return false;
}),
keys(queryParams).forEach(function(n) {
let dasherized = dasherize(n);
if (columns.indexOf(dasherized) !== -1) {
filterBy[dasherized] = queryParams[n];
}
});
export function dasherize(params/*, hash*/) {
let string = params[0];
return dash(string);
}
},
_normalize(fullName) {
// A) Convert underscores to dashes
// B) Convert camelCase to dash-case, except for helpers where we want to avoid shadowing camelCase expressions
// C) replace `.` with `/` in order to make nested controllers work in the following cases
// 1. `needs: ['posts/post']`
// 2. `{{render "posts/post"}}`
// 3. `this.render('posts/post')` from Route
let split = fullName.split(':');
if (split.length > 1) {
if (split[0] === 'helper') {
return split[0] + ':' + split[1].replace(/_/g, '-');
} else {
return split[0] + ':' + dasherize(split[1].replace(/\./g, '/'));
}
} else {
return fullName;
}
},
pluralize(type) {
return this.pluralizedTypes[type] || (this.pluralizedTypes[type] = type + 's');
},
podBasedLookupWithPrefix(podPrefix, parsedName) {
let fullNameWithoutType = parsedName.fullNameWithoutType;
if (parsedName.type === 'template') {
fullNameWithoutType = fullNameWithoutType.replace(/^components\//, '');
return attachment.split(' ').map((attachmentPart) => {
return `emd-attachment-${dasherize(attachmentPart)}`;
}).join(' ');
this._showAPIError(error, options);
});
}
this._showAPIError(resp, options);
},
_showAPIError(resp, options) {
options = options || {};
options.type = options.type || 'error';
// if possible use the title to get a unique key
// - we only show one alert for each key so if we get multiple errors
// only the last one will be shown
if (!options.key && !isBlank(get(resp, 'title'))) {
options.key = dasherize(get(resp, 'title'));
}
options.key = ['api-error', options.key].compact().join('.');
let msg = options.defaultErrorText || 'There was a problem on the server, please try again.';
if (resp instanceof String) {
msg = resp;
} else if (!isBlank(get(resp, 'detail'))) {
msg = resp.detail;
} else if (!isBlank(get(resp, 'message'))) {
msg = resp.message;
}
if (!isBlank(get(resp, 'context'))) {
msg = `${msg} ${get(resp, 'context')}`;
targetAttachmentClass: computed('targetAttachment', function() {
let targetAttachment = this.get('targetAttachment') || '';
// Convert tether-styled values like 'middle right' to 'right'
targetAttachment = targetAttachment.split(' ').slice(-1)[0];
return `ember-modal-dialog-target-attachment-${dasherize(targetAttachment)} emd-target-attachment-${dasherize(targetAttachment)}`;
}),
export default function setupStore(options) {
let container, registry, owner;
let env = {};
options = options || {};
if (Ember.Registry) {
registry = env.registry = new Ember.Registry();
owner = Owner.create({
__registry__: registry
});
container = env.container = registry.container({
owner: owner
});
owner.__container__ = container;
} else {
container = env.container = new Ember.Container();
registry = env.registry = container;
}
env.replaceContainerNormalize = function replaceContainerNormalize(fn) {
if (env.registry) {
env.registry.normalize = fn;
} else {
env.container.normalize = fn;
}
};
let adapter = env.adapter = (options.adapter || '-default');
delete options.adapter;
if (typeof adapter !== 'string') {
env.registry.register('adapter:-ember-data-test-custom', adapter);
adapter = '-ember-data-test-custom';
}
for (let prop in options) {
registry.register('model:' + dasherize(prop), options[prop]);
}
registry.register('service:store', DS.Store.extend({
adapter: adapter
}));
registry.optionsForType('serializer', { singleton: false });
registry.optionsForType('adapter', { singleton: false });
registry.register('adapter:-default', DS.Adapter);
registry.register('serializer:-default', DS.JSONAPISerializer);
registry.register('serializer:-json', DS.JSONSerializer);
registry.register('serializer:-rest', DS.RESTSerializer);
registry.register('adapter:-rest', DS.RESTAdapter);
registry.register('adapter:-json-api', DS.JSONAPIAdapter);
registry.injection('serializer', 'store', 'service:store');
env.store = container.lookup('service:store');
env.restSerializer = container.lookup('serializer:-rest');
env.restSerializer.store = env.store;
env.serializer = env.store.serializerFor('-default');
env.serializer.store = env.store;
// lazily create the adapter method because some tets depend on
// modifiying the adapter in the container after setupStore is
// called
Object.defineProperty(env, 'adapter', {
get() {
if (!this._adapter) {
this._adapter = this.store.adapterFor('application');
}
return this._adapter;
},
set(adapter) {
this._adapter = adapter;
},
enumerable: true,
configurable: true
});
return env;
}
// All modelNames are dasherized internally. Changing this function may
// require changes to other normalization hooks (such as typeForRoot).
/**
This method normalizes a modelName into the format Ember Data uses
internally.
@method normalizeModelName
@public
@param {String} modelName
@return {String} normalizedModelName
@for DS
*/
export default function normalizeModelName(modelName) {
return dasherize(modelName);
}
attributeClassName: computed('attr', function() {
let attr = this.get('attr');
return attr ? `${dasherize(attr)}-attr-input` : null;
}),
service.generateSlug('post', rawSlug).then(function (slug) {
expect(slug).to.equal(dasherize(rawSlug));
done();
});
dasherizedName: computed('name', function () {
return dasherize(this.get('name'));
}),