Subversion Repositories Applications.papyrus

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