if (RESERVED_KEYS.indexOf(key) !== -1) {

throw new Error(`key[${key}] is reserved`);

}

if (!(object && object[prop])) {

return null;

}

return _.isFunction(object[prop]) ? object[prop]() : object[prop];

// Allow new AV.Object("ClassName") as a shortcut to _create.

if (_.isString(attributes)) {

return AV.Object._create.apply(this, arguments);

}

attributes = attributes || {};

if (options && options.parse) {

attributes = this.parse(attributes);

attributes = this._mergeMagicFields(attributes);

}

var defaults = getValue(this, 'defaults');

if (defaults) {

attributes = _.extend({}, defaults, attributes);

}

if (options && options.collection) {

this.collection = options.collection;

}

this._serverData = {}; // The last known data for this object from cloud.

this._opSetQueue = [{}]; // List of sets of changes to the data.

this._flags = {};

this.attributes = {}; // The best estimate of this's current data.

this._hashedJSON = {}; // Hash of values of containers at last save.

this._escapedAttributes = {};

this.cid = _.uniqueId('c');

this.changed = {};

this._silent = {};

this._pending = {};

this.set(attributes, { silent: true });

this.changed = {};

this._silent = {};

this._pending = {};

this._hasData = true;

this._previousAttributes = _.clone(this.attributes);

this.initialize.apply(this, arguments);

AV.Promise.resolve().then(() =>

_request('batch', null, null, 'POST', {

requests: _.map(objects, object => {

if (!object.className) throw new Error('object must have className to fetch');

if (!object.id) throw new Error('object must have id to fetch');

if (object.dirty()) throw new Error('object is modified but not saved');

return {

method: 'GET',

path: `/1.1/classes/${object.className}/${object.id}`,

};

}),

}, options)

).then(function(response) {

_.forEach(objects, function(object, i) {

if (response[i].success) {

object._finishFetch(

object.parse(response[i].success));

} else {

const error = new Error(response[i].error.error);

error.code = response[i].error.code;

throw error;

}

});

return objects;

console.warn('AV.Object#fetchWhenSave is deprecated, use AV.Object#save with options.fetchWhenSave instead.');

if (!_.isBoolean(enable)) {

throw new Error('Expect boolean value for fetchWhenSave');

}

this._fetchWhenSave = enable;

var json = _.clone(this.attributes);

if (_.isArray(seenObjects)) {

var newSeenObjects = seenObjects.concat(this);

}

AV._objectEach(json, function(val, key) {

json[key] = AV._encode(val, newSeenObjects, undefined, full);

});

AV._objectEach(this._operations, function(val, key) {

json[key] = val;

});

if (_.has(this, "id")) {

json.objectId = this.id;

}

_(['createdAt', 'updatedAt']).each((key) => {

if (_.has(this, key)) {

const val = this[key];

json[key] = _.isDate(val) ? val.toJSON() : val;

}

});

if (full) {

json.__type = "Object";

if (_.isArray(seenObjects) && seenObjects.length) json.__type = "Pointer";

json.className = this.className;

}

return json;

var self = this;

if (self._refreshingCache) {

return;

}

self._refreshingCache = true;

AV._objectEach(this.attributes, function(value, key) {

if (value instanceof AV.Object) {

value._refreshCache();

} else if (_.isObject(value)) {

if (self._resetCacheForKey(key)) {

self.set(key, new AV.Op.Set(value), { silent: true });

}

}

});

delete self._refreshingCache;

this._refreshCache();

var currentChanges = _.last(this._opSetQueue);

if (attr) {

return (currentChanges[attr] ? true : false);

}

if (!this.id) {

return true;

}

if (_.keys(currentChanges).length > 0) {

return true;

}

return false;

// if (!this.id) {

// throw new Error("Can't serialize an unsaved AV.Object");

// }

return { __type: "Pointer",

className: this.className,

objectId: this.id };

switch (attr) {

case 'objectId':

return this.id;

case 'createdAt':

case 'updatedAt':

return this[attr];

default:

return this.attributes[attr];

}

var value = this.get(attr);

if (value) {

if (!(value instanceof AV.Relation)) {

throw new Error("Called relation() on non-relation field " + attr);

}

value._ensureParentAndKey(this, attr);

return value;

} else {

return new AV.Relation(this, attr);

}

var html = this._escapedAttributes[attr];

if (html) {

return html;

}

var val = this.attributes[attr];

var escaped;

if (isNullOrUndefined(val)) {

escaped = '';

} else {

escaped = _.escape(val.toString());

}

this._escapedAttributes[attr] = escaped;

return escaped;

// Check for changes of magic fields.

var model = this;

var specialFields = ["objectId", "createdAt", "updatedAt"];

AV._arrayEach(specialFields, function(attr) {

if (attrs[attr]) {

if (attr === "objectId") {

model.id = attrs[attr];

} else if ((attr === "createdAt" || attr === "updatedAt") &&

!_.isDate(attrs[attr])) {

model[attr] = AV._parseDate(attrs[attr]);

} else {

model[attr] = attrs[attr];

}

delete attrs[attr];

}

});

return attrs;

var self = this;

var failedChanges = _.first(this._opSetQueue);

this._opSetQueue = _.rest(this._opSetQueue);

var nextChanges = _.first(this._opSetQueue);

AV._objectEach(failedChanges, function(op, key) {

var op1 = failedChanges[key];

var op2 = nextChanges[key];

if (op1 && op2) {

nextChanges[key] = op2._mergeWithPrevious(op1);

} else if (op1) {

nextChanges[key] = op1;

}

});

this._saving = this._saving - 1;

// Grab a copy of any object referenced by this object. These instances

// may have already been fetched, and we don't want to lose their data.

// Note that doing it like this means we will unify separate copies of the

// same object, but that's a risk we have to take.

var fetchedObjects = {};

AV._traverse(this.attributes, function(object) {

if (object instanceof AV.Object && object.id && object._hasData) {

fetchedObjects[object.id] = object;

}

});

var savedChanges = _.first(this._opSetQueue);

this._opSetQueue = _.rest(this._opSetQueue);

this._applyOpSet(savedChanges, this._serverData);

this._mergeMagicFields(serverData);

var self = this;

AV._objectEach(serverData, function(value, key) {

self._serverData[key] = AV._decode(value, key);

// Look for any objects that might have become unfetched and fix them

// by replacing their values with the previously observed values.

var fetched = AV._traverse(self._serverData[key], function(object) {

if (object instanceof AV.Object && fetchedObjects[object.id]) {

return fetchedObjects[object.id];

}

});

if (fetched) {

self._serverData[key] = fetched;

}

});

this._rebuildAllEstimatedData();

this._saving = this._saving - 1;

// Clear out any changes the user might have made previously.

this._opSetQueue = [{}];

// Bring in all the new server data.

this._mergeMagicFields(serverData);

var self = this;

AV._objectEach(serverData, function(value, key) {

self._serverData[key] = AV._decode(value, key);

});

// Refresh the attributes.

this._rebuildAllEstimatedData();

// Clear out the cache of mutable containers.

this._refreshCache();

this._opSetQueue = [{}];

this._hasData = hasData;

var self = this;

AV._objectEach(opSet, function(change, key) {

target[key] = change._estimate(target[key], self, key);

if (target[key] === AV.Op._UNSET) {

delete target[key];

}

});

var value = this.attributes[key];

if (_.isObject(value) &&

!(value instanceof AV.Object) &&

!(value instanceof AV.File)) {

value = value.toJSON ? value.toJSON() : value;

var json = JSON.stringify(value);

if (this._hashedJSON[key] !== json) {

var wasSet = !! this._hashedJSON[key];

this._hashedJSON[key] = json;

return wasSet;

}

}

return false;

var self = this;

delete this.attributes[key];

if (this._serverData[key]) {

this.attributes[key] = this._serverData[key];

}

AV._arrayEach(this._opSetQueue, function(opSet) {

var op = opSet[key];

if (op) {

self.attributes[key] = op._estimate(self.attributes[key], self, key);

if (self.attributes[key] === AV.Op._UNSET) {

delete self.attributes[key];

} else {

self._resetCacheForKey(key);

}

}

});

var self = this;

var previousAttributes = _.clone(this.attributes);

this.attributes = _.clone(this._serverData);

AV._arrayEach(this._opSetQueue, function(opSet) {

self._applyOpSet(opSet, self.attributes);

AV._objectEach(opSet, function(op, key) {

self._resetCacheForKey(key);

});

});

// Trigger change events for anything that changed because of the fetch.

AV._objectEach(previousAttributes, function(oldValue, key) {

if (self.attributes[key] !== oldValue) {

self.trigger('change:' + key, self, self.attributes[key], {});

}

});

AV._objectEach(this.attributes, function(newValue, key) {

if (!_.has(previousAttributes, key)) {

self.trigger('change:' + key, self, newValue, {});

}

});

var attrs;

if (_.isObject(key) || isNullOrUndefined(key)) {

attrs = _.mapObject(key, function(v, k) {

checkReservedKey(k);

return AV._decode(v, k);

});

options = value;

} else {

attrs = {};

checkReservedKey(key);

attrs[key] = AV._decode(value, key);

}

// Extract attributes and options.

options = options || {};

if (!attrs) {

return this;

}

if (attrs instanceof AV.Object) {

attrs = attrs.attributes;

}

// If the unset option is used, every attribute should be a Unset.

if (options.unset) {

AV._objectEach(attrs, function(unused_value, key) {

attrs[key] = new AV.Op.Unset();

});

}

// Apply all the attributes to get the estimated values.

var dataToValidate = _.clone(attrs);

var self = this;

AV._objectEach(dataToValidate, function(value, key) {

if (value instanceof AV.Op) {

dataToValidate[key] = value._estimate(self.attributes[key],

self, key);

if (dataToValidate[key] === AV.Op._UNSET) {

delete dataToValidate[key];

}

}

});

// Run validation.

this._validate(attrs, options);

options.changes = {};

var escaped = this._escapedAttributes;

var prev = this._previousAttributes || {};

// Update attributes.

AV._arrayEach(_.keys(attrs), function(attr) {

var val = attrs[attr];

// If this is a relation object we need to set the parent correctly,

// since the location where it was parsed does not have access to

// this object.

if (val instanceof AV.Relation) {

val.parent = self;

}

if (!(val instanceof AV.Op)) {

val = new AV.Op.Set(val);

}

// See if this change will actually have any effect.

var isRealChange = true;

if (val instanceof AV.Op.Set &&

_.isEqual(self.attributes[attr], val.value)) {

isRealChange = false;

}

if (isRealChange) {

delete escaped[attr];

if (options.silent) {

self._silent[attr] = true;

} else {

options.changes[attr] = true;

}

}

var currentChanges = _.last(self._opSetQueue);

currentChanges[attr] = val._mergeWithPrevious(currentChanges[attr]);

self._rebuildEstimatedDataForKey(attr);

if (isRealChange) {

self.changed[attr] = self.attributes[attr];

if (!options.silent) {

self._pending[attr] = true;

}

} else {

delete self.changed[attr];

delete self._pending[attr];

}

});

if (!options.silent) {

this.change(options);

}

return this;

options = options || {};

options.unset = true;

return this.set(attr, null, options);

if (_.isUndefined(amount) || _.isNull(amount)) {

amount = 1;

}

return this.set(attr, new AV.Op.Increment(amount));

options = options || {};

options.unset = true;

var keysToClear = _.extend(this.attributes, this._operations);

return this.set(keysToClear, options);

var json = _.clone(_.first(this._opSetQueue));

AV._objectEach(json, function(op, key) {

json[key] = op.toJSON();

});

return json;

var self = this;

var request = _request('classes', this.className, this.id, 'GET',

transformFetchOptions(fetchOptions), options);

return request.then(function(response) {

self._finishFetch(self.parse(response), true);

return self;

});

var i, attrs, current, options, saved;

if (_.isObject(arg1) || isNullOrUndefined(arg1)) {

attrs = arg1;

options = arg2;

} else {

attrs = {};

attrs[arg1] = arg2;

options = arg3;

}