import DS from 'ember-data';
export default DS.RESTSerializer.extend({
normalizeResponse(store, primaryModelClass, payload, id) {
payload.astronomy = { };
payload.astronomy.id = id;
// jscs:disable requireCamelCaseOrUpperCaseIdentifiers
payload.astronomy.moon = payload.moon_phase;
delete payload.response;
delete payload.moon_phase;
delete payload.sun_phase;
// jscs:enable requireCamelCaseOrUpperCaseIdentifiers
return this._super(...arguments);
}
});
import DS from "ember-data";
var ModelSerializer = DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
attrs: {
properties: { embedded: 'always' }
},
extractSingle: function (store, type, payload, id) {
payload = { "model": payload };
return this._super(store, type, payload, id);
}
});
export default ModelSerializer;
export default DS.RESTSerializer.extend({ //ActiveModel
/*
`__requestType` is used to know if we are
dealing with a list resource (i.e., GET /users) which may
have meta data in the root of the payload, i.e.:
{
page: 1, // <-- metadata
total_pages: 5, // <-- metadata
_embedded: {
users: [{...}, ...]
}
}
If the requestType is for a single resource we cannot determine
which properties are metadata and which are part of the payload
for that resource because they are all at the root level of the payload,
so punt on that here -- per-model serializers can override extractMeta
if they need to.
@return {Object} The payload, modified to remove metadata
*/
extractMeta: function(store, type, payload){
var requestType = this.__requestType;
if ( findManyRequestTypes.indexOf(requestType) > -1 ) {
var meta = {};
Ember.keys(payload).forEach(function(key){
if (reservedKeys.indexOf(key) > -1) { return; }
meta[key] = payload[key];
delete payload[key];
});
meta = extractLinksIntoMeta(payload, meta);
setMeta(store, type, meta);
}
this._super(store, type, payload);
return payload;
},
/*
* Override `extract` so we can store the requestType for extractMeta
*/
extract: function(store, type, payload, id, requestType) {
this.__requestType = requestType; // used by `extractMeta`
return this._super(store, type, payload, id, requestType);
},
/**
* https://github.com/emberjs/data/blob/48c02654e8a524b390d1a28975416ee73f912d9e/packages/ember-data/lib/serializers/rest_serializer.js#L263
@method extractSingle
@param {DS.Store} store
@param {subclass of DS.Model} primaryType
@param {Object} payload
@param {String} recordId
@return {Object} the primary response to the original request
*/
extractSingle: function(store, primaryType, rawPayload, recordId) {
var extracted = new EmbedExtractor(rawPayload, store, this).
extractSingle(primaryType);
return this._super(store, primaryType, extracted, recordId);
},
/*
* https://github.com/emberjs/data/blob/48c02654e8a524b390d1a28975416ee73f912d9e/packages/ember-data/lib/serializers/rest_serializer.js#L417
@method extractArray
@param {DS.Store} store
@param {subclass of DS.Model} primaryType
@param {Object} payload
@return {Array} The primary array that was returned in response
to the original query.
*/
extractArray: function(store, primaryType, rawPayload) {
var extracted = new EmbedExtractor(rawPayload, store, this).
extractArray(primaryType);
return this._super(store, primaryType, extracted);
},
normalizePayload: function(payload){
// top-level _links (such as 'self') can be ignored
if (payload._links) {
delete payload._links;
}
return this._super(payload);
},
normalize: function(type, hash, property) {
var links = hash._links || {};
delete hash._links;
hash.links = hash.links || {};
Ember.keys(links).forEach(function(link){
// Do not include a link for a property that already
// exists on the hash, because Ember-Data will fetch that
// resource by the link instead of using the included data
if(link === 'self') {
var href = links[link].href;
var id = href.substring(href.lastIndexOf('/') + 1, href.length);
hash.id = id;
} if (!hash[link]) {
hash.links[link] = links[link].href;
}
});
return this._super(type, hash, property);
}
});
export default DS.RESTSerializer.extend({
isNewSerializerAPI: true,
attrs: {
champion: {key: "championId"},
role: {key: "roleId"}
},
/*modelNameFromPayloadKey: function(key){
return this._super("user-champion");
},
normalizeResponse: function(store, primaryModelClass, payload, id, requestType){
//payload.role = payload.role.id;
let userChampArr = Ember.A();
payload.forEach((item)=>{
userChampArr.addObject({"user-champion": item });
});
payload = {"user-champions": userChampArr};
return this._super(store, primaryModelClass, payload, id, requestType);
}*/
});
import { merge } from '@ember/polyfills';
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
/**
* Override the serializeIntoHash method
* See http://emberjs.com/api/data/classes/DS.RESTSerializer.html#method_serializeIntoHash
* @method serializeIntoHash
*/
serializeIntoHash(hash, typeClass, snapshot) {
const dirty = snapshot.changedAttributes();
Object.keys(dirty).forEach((key) => {
dirty[key] = dirty[key][1];
});
const h = merge(hash, dirty);
delete h.lastUsed;
delete h.userId;
delete h.action;
delete h.pipelineId;
return h;
}
});
import {
extractSingle as parseSingle,
extractArray as parseArray
} from "nmf-schedule/extractors/event";
export default DS.RESTSerializer.extend({
normalizeSingleResponse(store, type, payload, id, requestType) {
console.log('running extractSingle');
payload = parseSingle(payload);
this.extractMeta(store, type, payload);
return this._super(store, type, payload, id, requestType);
},
normalizeArrayResponse(store, type, payload, id, requestType) {
console.log('running normalizeArrayResponse');
payload = parseArray(payload);
console.log("payload ---------");
console.log(payload);
this.extractMeta(store, type, payload, id, requestType);
var returnValue = this._super(store, type, payload, id, requestType);
console.log("-----------");
console.log(returnValue);
return returnValue;
}
});
/**
* Created by suchita on 4/8/15.
*/
import Ember from 'ember';
import DS from 'ember-data';
export default
DS.RESTSerializer.extend({
extractArray: function (store, type, record) {
return record.blog.posts;
}
});
import DS from 'ember-data';
import Ember from 'ember';
export default DS.RESTSerializer.extend( DS.EmbeddedRecordsMixin, {
primaryKey : "product_id",
extractMeta : function (store, type, payload){
payload.meta = Ember.Object.create({
"count" : payload.count,
"next" : payload.next,
"start" : payload.start || 0,
"total" : payload.total || 0,
"refinements" : Ember.A(payload.refinements),
"selected_refinements" : Ember.Object.create(payload.selected_refinements),
});
delete payload.count;
delete payload.next;
delete payload.start;
delete payload.total;
delete payload.refinements;
delete payload.selected_refinements;
return this._super(store, type, payload);
},
normalizePayload : function (payload){
delete payload._v;
var hits = payload.hits || [];
delete payload.hits;
return { "ProductSearch" : hits};
},
});
import { RESTSerializer } from 'ember-data';
var BaseSerializer = RESTSerializer.extend({
normalizePayload: function(primaryType, payload){
var data = {};
if (Array.isArray(payload)) {
data[primaryType.typeKey+'s'] = payload;
} else {
data[primaryType.typeKey] = payload;
}
return data;
},
extractMeta: function(store, type, payload){
if(payload.meta && payload.meta.next){
payload.meta.next = payload.meta.next.replace("https://localhost", "http://localhost:8080");
}
this._super(store, type, payload);
}
});
export default BaseSerializer;
export default DS.RESTSerializer.extend({
/**
@method normalize - swap id w/ slug
**/
normalize: function(type, hash) {
if (!hash) { return hash; }
this.applyTransforms(type, hash);
var slug = hash.slug;
hash.slug = hash.id;
hash.id = slug;
return hash;
},
/**
@method serialize - swap id back to slug
**/
serialize: function (record/*, options*/) {
var json = this._super.apply(this, arguments);
if (!json) { return json; }
if (json.id) {
json.id = record.get('slug');
}
var id = record.get('id');
if (id) {
json.slug = id;
}
return json;
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
primaryKey: '_id',
extractArray: function (store, type, payload) {
var payloadTemp = {};
payload.forEach(function (item) {
// mongodb coordinates order is [longitude,latitude]
item.lng = item.location.coordinates[0];
item.lat = item.location.coordinates[1];
// console.log('lat:' + item.lat + ', lng:' + item.lng);
})
payloadTemp[type.typeKey] = payload;
return this._super(store, type, payloadTemp);
},
extractSingle: function (store, type, payload, id) {
var payloadTemp = {};
payloadTemp[type.typeKey] = [payload];
return this._super(store, type, payloadTemp, id);
}
});
// export default DS.RESTSerializer.extend({
// isNewSerializerAPI: false,
// primaryKey: '_id',
// extractArray: function (store, type, payload) {
// payload.forEach(function (item) {
// // mongodb coordinates order is [longitude,latitude]
// item.lng = item.location.coordinates[0];
// item.lat = item.location.coordinates[1];
export default DS.RESTSerializer.extend({
keyForAttribute: function(attr) {
return decamelize(attr);
},
extractLazyPaginatedData(payload) {
let ret;
ret = payload.data.keys.map(key => {
let model = {
id: key,
};
if (payload.backend) {
model.backend = payload.backend;
}
return model;
});
return ret;
},
normalizeItems(payload) {
if (payload.data.keys && Array.isArray(payload.data.keys)) {
return payload.data.keys;
}
Ember.assign(payload, payload.data);
delete payload.data;
return [payload];
},
modelNameFromPayloadKey(payloadType) {
return payloadType;
},
normalizeResponse(store, primaryModelClass, payload, id, requestType) {
const nullResponses = ['updateRecord', 'createRecord', 'deleteRecord'];
const responseJSON = nullResponses.includes(requestType) ? { id } : this.normalizeItems(payload);
const { modelName } = primaryModelClass;
let transformedPayload = { [modelName]: responseJSON };
// just return the single object because ember is picky
if (requestType === 'queryRecord') {
transformedPayload = { [modelName]: responseJSON[0] };
}
return this._super(store, primaryModelClass, transformedPayload, id, requestType);
},
serializeAttribute(snapshot, json, key, attributes) {
const val = snapshot.attr(key);
if (attributes.options.readOnly) {
return;
}
if (
attributes.type === 'object' &&
val &&
Object.keys(val).length > 0 &&
Ember.isNone(snapshot.changedAttributes()[key])
) {
return;
}
if (Ember.isBlank(val) && Ember.isNone(snapshot.changedAttributes()[key])) {
return;
}
this._super(snapshot, json, key, attributes);
},
serialize() {
return this._super(...arguments);
},
});
import DS from 'ember-data';
// app/serializers/cat.js
export default DS.RESTSerializer.extend({
normalizeResponse(store, primaryModelClass, payload, id, requestType) {
payload = {
user: payload.user
};
return this._super(store, primaryModelClass, payload, id, requestType);
}
});
import DS from 'ember-data';
import Ember from 'ember';
export default DS.RESTSerializer.extend({
keyForAttribute: function(attr) {
return Ember.String.underscore(attr);
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
normalizeResponse(store, primaryModelClass, payload, id) {
payload.webcam = {
id,
webcams: payload.webcams
};
delete payload.webcams;
delete payload.response;
return this._super(...arguments);
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
attrs: {
reWows: {embedded: 'always'},
wowedBy: {embedded: 'always'}
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
normalizePayload: function(payload) {
payload.doc.forEach(function(journal) {
// set id
journal.id = journal.config.id = journal.timestamp;
// transform environment variable objects
var envKeys = [];
var envkeysObject = journal.config.env;
Object.keys(envkeysObject).map(function(data) {
envKeys.push({
key: data,
value: envkeysObject[data]
});
});
journal.config.env = envKeys;
});
return { journal: payload.doc };
},
attrs: {
config: {embedded: 'always'},
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
primaryKey: '_id',
serializeId: function(id) {
return id.toString();
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
primaryKey: 'crate_id',
modelNameFromPayloadKey() {
return 'crate-owner-invite';
},
payloadKeyFromModelName() {
return 'crate_owner_invite';
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
// add root node 'entitlements' that customer protal JSON response doesn't return
extractArray: function(store, type, payload) {
payload = { pools: payload };
return this._super(store, type, payload);
},
// remove attribute keys in the json response that aren't in the model management application
normalizeHash: {
management_applications: function(hash) {
delete hash.releaseVer;
delete hash.type;
delete hash.owner;
delete hash.installedProducts;
delete hash.guestIds;
delete hash.capabilities;
return hash;
}
}
});
import DS from 'ember-data';
/* global _:true */
export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
attrs: {
rates: { embedded: 'always' }
},
extract: function(store, type, payload, id, requestType) {
var data = {
currency: [{
id: 1,
base: payload.base
}]
};
var _id = 1;
data.currency[0].rates = _.map(payload.rates, function(rate, code) {
return {
id: _id++,
code: code,
rate: rate
};
});
return this._super(store, type, data, id, requestType);
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
normalizeResponse(store, primaryModelClass, payload, id) {
payload.rgeocode = payload.results[ 0 ] || {};
payload.rgeocode.id = id;
delete payload.results;
delete payload.status;
return this._super(...arguments);
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
normalizePayload(payload) {
return { livestock: payload.data };
}
});
export default DS.RESTSerializer.extend({
keyForAttribute: function(attr) {
return decamelize(attr);
},
pushPayload(store, payload) {
const transformedPayload = this.normalizeResponse(
store,
store.modelFor(payload.modelName),
payload,
payload.id,
'findRecord'
);
return store.push(transformedPayload);
},
normalizeItems(payload) {
Ember.assign(payload, payload.data);
delete payload.data;
return payload;
},
normalizeResponse(store, primaryModelClass, payload, id, requestType) {
const responseJSON = this.normalizeItems(payload);
const { modelName } = primaryModelClass;
let transformedPayload = { [modelName]: responseJSON };
let ret = this._super(store, primaryModelClass, transformedPayload, id, requestType);
return ret;
},
serializeAttribute(snapshot, json, key, attributes) {
const val = snapshot.attr(key);
if (attributes.options.readOnly) {
return;
}
if (
attributes.type === 'object' &&
val &&
Object.keys(val).length > 0 &&
Ember.isNone(snapshot.changedAttributes()[key])
) {
return;
}
if (Ember.isBlank(val) && Ember.isNone(snapshot.changedAttributes()[key])) {
return;
}
this._super(snapshot, json, key, attributes);
},
});
// app/serializers/picture.js
import DS from "ember-data";
export default DS.RESTSerializer.extend({
});
export default DS.RESTSerializer.extend({
normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {
let data = {};
let pluralized = Ember.String.pluralize(primaryModelClass.modelName);
data[pluralized] = payload.collection;
delete payload.collection;
data['meta'] = {
offset: payload.offset,
limit: payload.limit,
total: payload.total
};
delete payload.page;
delete payload.total;
delete payload.offset;
delete payload.limit;
return this._super(store, primaryModelClass, data, id, requestType);
},
normalizeSingleResponse(store, primaryModelClass, payload, id, requestType) {
let data = {};
data[primaryModelClass.modelName] = payload;
return this._normalizeResponse(store, primaryModelClass, data, id, requestType, true);
},
/**
* Excludes a root object when serializing to JSON.
* @param hash the payload.
* @param type the model type.
* @param snapshot the record.
* @param options options.
*/
serializeIntoHash: function(hash, type, snapshot, options) {
Ember.merge(hash, this.serialize(snapshot, options));
},
/**
* Includes identifiers when serializing to JSON.
* @param record the record to serialize.
* @param options options.
* @returns {*}
*/
serialize: function(snapshot, options) {
options = options || { includeId: true };
return this._super(snapshot, options);
}
});
host: 'http://www.weeatt.com',
headers: {
'x-api-key': ENV.WEEATT_API_KEY,
'Accept': 'application/json',
'Content-Type': 'application/json'
},
ajax: function(url, type, hash) {
if (Ember.isEmpty(hash)) {
hash = {};
}
if (Ember.isEmpty(hash.data)) {
hash.data = {};
}
hash.data.auth_token = ENV.WEEATT_AUTH_TOKEN;
return this._super(url, type, hash);
}
});
DS.RESTSerializer.reopen({
normalizePayload: function(payload) {
var normalizedRecipes = {"recipes": payload.results};
return normalizedRecipes;
}
});
loadInitializers(App, config.modulePrefix);
export default App;
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
normalizeFindAllResponse(store, primaryModelClass, payload, id, requestType) {
payload['accounts'] = payload['data'];
delete payload['data'];
payload.accounts.forEach((account) => {
account.links = {
page: '/'+ account.id +'?fields=access_token,name&access_token='+ account.access_token
}
});
return this._super(...arguments);
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
modelNameFromPayloadKey: function(payloadKey) {
if (payloadKey === 'tiposgastos') {
return this._super("tipogasto");
} else {
return this._super(payloadKey);
}
}
});
import DS from 'ember-data';
export default DS.RESTSerializer.extend({
primaryKey: 'session_id',
modelNameFromPayloadKey: function(payloadKey) {
return payloadKey;
}
});