in plugins/struts2-dojo-plugin/src/main/resources/org/apache/struts2/static/dojo/src/data/core/RemoteStore.js [23:353]
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;
}});