remotestore.js

初学者

/*
	Copyright (c) 2004-2006, The Dojo Foundation
	All Rights Reserved.

	Licensed under the Academic Free License version 2.1 or above OR the
	modified BSD license. For more information on Dojo licensing, see:

		http://dojotoolkit.org/community/licensing.shtml
*/



dojo.provide("dojo.data.core.RemoteStore");
dojo.require("dojo.data.core.Read");
dojo.require("dojo.data.core.Write");
dojo.require("dojo.data.core.Result");
dojo.require("dojo.experimental");
dojo.require("dojo.Deferred");
dojo.require("dojo.lang.declare");
dojo.require("dojo.json");
dojo.require("dojo.io.*");
dojo.experimental("dojo.data.core.RemoteStore");
dojo.lang.declare("dojo.data.core.RemoteStore", [dojo.data.core.Read, dojo.data.core.Write], {_datatypeMap:{}, _jsonRegistry:dojo.json.jsonRegistry, initializer:function (kwArgs) {
	if (!kwArgs) {
		kwArgs = {};
	}
	this._serverQueryUrl = kwArgs.queryUrl || "";
	this._serverSaveUrl = kwArgs.saveUrl || "";
	this._deleted = {};
	this._changed = {};
	this._added = {};
	this._results = {};
	this._data = {};
	this._numItems = 0;
}, _setupQueryRequest:function (result, requestKw) {
	result.query = result.query || "";
	requestKw.url = this._serverQueryUrl + encodeURIComponent(result.query);
	requestKw.method = "get";
	requestKw.mimetype = "text/json";
}, _resultToQueryMetadata:function (serverResponseData) {
	return serverResponseData;
}, _resultToQueryData:function (serverResponseData) {
	return serverResponseData.data;
}, _remoteToLocalValues:function (attributes) {
	for (var key in attributes) {
		var values = attributes[key];
		for (var i = 0; i < values.length; i++) {
			var value = values[i];
			var type = value.datatype || value.type;
			if (type) {
				var localValue = value.value;
				if (this._datatypeMap[type]) {
					localValue = this._datatypeMap[type](value);
				}
				values[i] = localValue;
			}
		}
	}
	return attributes;
}, _queryToQueryKey:function (query) {
	if (typeof query == "string") {
		return query;
	} else {
		return dojo.json.serialize(query);
	}
}, _assertIsItem:function (item) {
	if (!this.isItem(item)) {
		throw new Error("dojo.data.RemoteStore: a function was passed an item argument that was not an item");
	}
}, get:function (item, attribute, defaultValue) {
	var valueArray = this.getValues(item, attribute);
	if (valueArray.length == 0) {
		return defaultValue;
	}
	return valueArray[0];
}, getValues:function (item, attribute) {
	var itemIdentity = this.getIdentity(item);
	this._assertIsItem(itemIdentity);
	var changes = this._changed[itemIdentity];
	if (changes) {
		var newvalues = changes[attribute];
		if (newvalues !== undefined) {
			return newvalues;
		} else {
			return [];
		}
	}
	return this._data[itemIdentity][0][attribute];
}, getAttributes:function (item) {
	var itemIdentity = this.getIdentity(item);
	if (!itemIdentity) {
		return undefined;
	}
	var atts = [];
	var attrDict = this._data[itemIdentity][0];
	for (var att in attrDict) {
		atts.push(att);
	}
	return atts;
}, hasAttribute:function (item, attribute) {
	var valueArray = this.getValues(item, attribute);
	return valueArray.length ? true : false;
}, containsValue:function (item, attribute, value) {
	var valueArray = this.getValues(item, attribute);
	for (var i = 0; i < valueArray.length; i++) {
		if (valueArray[i] == value) {
			return true;
		}
	}
	return false;
}, isItem:function (something) {
	if (!something) {
		return false;
	}
	var itemIdentity = something;
	if (this._deleted[itemIdentity]) {
		return false;
	}
	if (this._data[itemIdentity]) {
		return true;
	}
	if (this._added[itemIdentity]) {
		return true;
	}
	return false;
}, find:function (keywordArgs) {
	var result = null;
	if (keywordArgs instanceof dojo.data.core.Result) {
		result = keywordArgs;
		result.store = this;
	} else {
		result = new dojo.data.core.Result(keywordArgs, this);
	}
	var query = result.query;
	var self = this;
	var bindfunc = function (type, data, evt) {
		var scope = result.scope || dj_global;
		if (type == "load") {
			result.resultMetadata = self._resultToQueryMetadata(data);
			var dataDict = self._resultToQueryData(data);
			if (result.onbegin) {
				result.onbegin.call(scope, result);
			}
			var count = 0;
			var resultData = [];
			var newItemCount = 0;
			for (var key in dataDict) {
				if (result._aborted) {
					break;
				}
				if (!self._deleted[key]) {
					var values = dataDict[key];
					var attributeDict = self._remoteToLocalValues(values);
					var existingValue = self._data[key];
					var refCount = 1;
					if (existingValue) {
						refCount = ++existingValue[1];
					} else {
						newItemCount++;
					}
					self._data[key] = [attributeDict, refCount];
					resultData.push(key);
					count++;
					if (result.onnext) {
						result.onnext.call(scope, key, result);
					}
				}
			}
			self._results[self._queryToQueryKey(query)] = resultData;
			self._numItems += newItemCount;
			result.length = count;
			if (result.saveResult) {
				result.items = resultData;
			}
			if (!result._aborted && result.oncompleted) {
				result.oncompleted.call(scope, result);
			}
		} else {
			if (type == "error" || type == "timeout") {
				dojo.debug("find error: " + dojo.json.serialize(data));
				if (result.onerror) {
					result.onerror.call(scope, data);
				}
			}
		}
	};
	var bindKw = keywordArgs.bindArgs || {};
	bindKw.sync = result.sync;
	bindKw.handle = bindfunc;
	this._setupQueryRequest(result, bindKw);
	var request = dojo.io.bind(bindKw);
	result._abortFunc = request.abort;
	return result;
}, getIdentity:function (item) {
	if (!this.isItem(item)) {
		return null;
	}
	return (item.id ? item.id : item);
}, newItem:function (attributes, keywordArgs) {
	var itemIdentity = keywordArgs["identity"];
	if (this._deleted[itemIdentity]) {
		delete this._deleted[itemIdentity];
	} else {
		this._added[itemIdentity] = 1;
	}
	if (attributes) {
		for (var attribute in attributes) {
			var valueOrArrayOfValues = attributes[attribute];
			if (dojo.lang.isArray(valueOrArrayOfValues)) {
				this.setValues(itemIdentity, attribute, valueOrArrayOfValues);
			} else {
				this.set(itemIdentity, attribute, valueOrArrayOfValues);
			}
		}
	}
	return {id:itemIdentity};
}, deleteItem:function (item) {
	var identity = this.getIdentity(item);
	if (!identity) {
		return false;
	}
	if (this._added[identity]) {
		delete this._added[identity];
	} else {
		this._deleted[identity] = 1;
	}
	if (this._changed[identity]) {
		delete this._changed[identity];
	}
	return true;
}, setValues:function (item, attribute, values) {
	var identity = this.getIdentity(item);
	if (!identity) {
		return undefined;
	}
	var changes = this._changed[identity];
	if (!changes) {
		changes = {};
		this._changed[identity] = changes;
	}
	changes[attribute] = values;
	return true;
}, set:function (item, attribute, value) {
	return this.setValues(item, attribute, [value]);
}, unsetAttribute:function (item, attribute) {
	return this.setValues(item, attribute, []);
}, _initChanges:function () {
	this._deleted = {};
	this._changed = {};
	this._added = {};
}, _setupSaveRequest:function (saveKeywordArgs, requestKw) {
	requestKw.url = this._serverSaveUrl;
	requestKw.method = "post";
	requestKw.mimetype = "text/plain";
	var deleted = [];
	for (var key in this._deleted) {
		deleted.push(key);
	}
	var saveStruct = {"changed":this._changed, "deleted":deleted};
	var oldRegistry = dojo.json.jsonRegistry;
	dojo.json.jsonRegistry = this._jsonRegistry;
	var jsonString = dojo.json.serialize(saveStruct);
	dojo.json.jsonRegistry = oldRegistry;
	requestKw.postContent = jsonString;
}, save:function (keywordArgs) {
	keywordArgs = keywordArgs || {};
	var result = new dojo.Deferred();
	var self = this;
	var bindfunc = function (type, data, evt) {
		if (type == "load") {
			if (result.fired == 1) {
				return;
			}
			var key = null;
			for (key in self._added) {
				if (!self._data[key]) {
					self._data[key] = [{}, 1];
				}
			}
			for (key in self._changed) {
				var existing = self._data[key];
				var changes = self._changed[key];
				if (existing) {
					existing[0] = changes;
				} else {
					self._data[key] = [changes, 1];
				}
			}
			for (key in self._deleted) {
				if (self._data[key]) {
					delete self._data[key];
				}
			}
			self._initChanges();
			result.callback(true);
		} else {
			if (type == "error" || type == "timeout") {
				result.errback(data);
			}
		}
	};
	var bindKw = {sync:keywordArgs["sync"], handle:bindfunc};
	this._setupSaveRequest(keywordArgs, bindKw);
	var request = dojo.io.bind(bindKw);
	result.canceller = function (deferred) {
		request.abort();
	};
	return result;
}, revert:function () {
	this._initChanges();
	return true;
}, isDirty:function (item) {
	if (item) {
		var identity = item.id || item;
		return this._deleted[identity] || this._changed[identity];
	} else {
		var key = null;
		for (key in this._changed) {
			return true;
		}
		for (key in this._deleted) {
			return true;
		}
		for (key in this._added) {
			return true;
		}
		return false;
	}
}, createReference:function (idstring) {
	return {id:idstring};
}, getSize:function () {
	return this._numItems;
}, forgetResults:function (query) {
	var queryKey = this._queryToQueryKey(query);
	var results = this._results[queryKey];
	if (!results) {
		return false;
	}
	var removed = 0;
	for (var i = 0; i < results.length; i++) {
		var key = results[i];
		var existingValue = this._data[key];
		if (existingValue[1] <= 1) {
			delete this._data[key];
			removed++;
		} else {
			existingValue[1] = --existingValue[1];
		}
	}
	delete this._results[queryKey];
	this._numItems -= removed;
	return true;
}});