Struts example source code file (RemoteStore.js)

This example Struts source code file (RemoteStore.js) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Struts tags/keywords

error, error

The Struts RemoteStore.js source code

/*
	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;
}});