From f0cfe83e3725f9a3928da97a6e3085e79cb25309 Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Mon, 18 Mar 2013 10:26:24 +0400 Subject: upgrade dojo to 1.8.3 (refs #570) --- lib/dojo/store/DataStore.js.uncompressed.js | 202 ++++++++++++++++++++++++++++ 1 file changed, 202 insertions(+) create mode 100644 lib/dojo/store/DataStore.js.uncompressed.js (limited to 'lib/dojo/store/DataStore.js.uncompressed.js') diff --git a/lib/dojo/store/DataStore.js.uncompressed.js b/lib/dojo/store/DataStore.js.uncompressed.js new file mode 100644 index 000000000..47a1fb9d8 --- /dev/null +++ b/lib/dojo/store/DataStore.js.uncompressed.js @@ -0,0 +1,202 @@ +define("dojo/store/DataStore", [ + "../_base/lang", "../_base/declare", "../_base/Deferred", "../_base/array", + "./util/QueryResults", "./util/SimpleQueryEngine" /*=====, "./api/Store" =====*/ +], function(lang, declare, Deferred, array, QueryResults, SimpleQueryEngine /*=====, Store =====*/){ + +// module: +// dojo/store/DataStore + + +// No base class, but for purposes of documentation, the base class is dojo/store/api/Store +var base = null; +/*===== base = Store; =====*/ + +return declare("dojo.store.DataStore", base, { + // summary: + // This is an adapter for using Dojo Data stores with an object store consumer. + // You can provide a Dojo data store and use this adapter to interact with it through + // the Dojo object store API + + target: "", + constructor: function(options){ + // options: Object? + // This provides any configuration information that will be mixed into the store, + // including a reference to the Dojo data store under the property "store". + lang.mixin(this, options); + if(!"idProperty" in options){ + var idAttribute; + try{ + idAttribute = this.store.getIdentityAttributes(); + }catch(e){ + // some store are not requiring an item instance to give us the ID attributes + // but some other do and throw errors in that case. + } + // if no idAttribute we have implicit id + this.idProperty = (!idAttribute || !idAttributes[0]) || this.idProperty; + } + var features = this.store.getFeatures(); + // check the feature set and null out any methods that shouldn't be available + if(!features["dojo.data.api.Read"]){ + this.get = null; + } + if(!features["dojo.data.api.Identity"]){ + this.getIdentity = null; + } + if(!features["dojo.data.api.Write"]){ + this.put = this.add = null; + } + }, + // idProperty: String + // The object property to use to store the identity of the store items. + idProperty: "id", + // store: + // The object store to convert to a data store + store: null, + // queryEngine: Function + // Defines the query engine to use for querying the data store + queryEngine: SimpleQueryEngine, + + _objectConverter: function(callback){ + var store = this.store; + var idProperty = this.idProperty; + function convert(item){ + var object = {}; + var attributes = store.getAttributes(item); + for(var i = 0; i < attributes.length; i++){ + var attribute = attributes[i]; + var values = store.getValues(item, attribute); + if(values.length > 1){ + for(var j = 0; j < values.length; j++){ + var value = values[j]; + if(typeof value == 'object' && store.isItem(value)){ + values[j] = convert(value); + } + } + value = values; + }else{ + var value = store.getValue(item, attribute); + if(typeof value == 'object' && store.isItem(value)){ + value = convert(value); + } + } + object[attributes[i]] = value; + } + if(!(idProperty in object) && store.getIdentity){ + object[idProperty] = store.getIdentity(item); + } + return object; + } + return function(item){ + return callback(convert(item)); + }; + }, + get: function(id, options){ + // summary: + // Retrieves an object by it's identity. This will trigger a fetchItemByIdentity + // id: Object? + // The identity to use to lookup the object + var returnedObject, returnedError; + var deferred = new Deferred(); + this.store.fetchItemByIdentity({ + identity: id, + onItem: this._objectConverter(function(object){ + deferred.resolve(returnedObject = object); + }), + onError: function(error){ + deferred.reject(returnedError = error); + } + }); + if(returnedObject){ + // if it was returned synchronously + return returnedObject; + } + if(returnedError){ + throw returnedError; + } + return deferred.promise; + }, + put: function(object, options){ + // summary: + // Stores an object by its identity. + // object: Object + // The object to store. + // options: Object? + // Additional metadata for storing the data. Includes a reference to an id + // that the object may be stored with (i.e. { id: "foo" }). + var id = options && typeof options.id != "undefined" || this.getIdentity(object); + var store = this.store; + var idProperty = this.idProperty; + if(typeof id == "undefined"){ + store.newItem(object); + store.save(); + }else{ + store.fetchItemByIdentity({ + identity: id, + onItem: function(item){ + if(item){ + for(var i in object){ + if(i != idProperty && // don't copy id properties since they are immutable and should be omitted for implicit ids + store.getValue(item, i) != object[i]){ + store.setValue(item, i, object[i]); + } + } + }else{ + store.newItem(object); + } + store.save(); + } + }); + } + }, + remove: function(id){ + // summary: + // Deletes an object by its identity. + // id: Object + // The identity to use to delete the object + var store = this.store; + this.store.fetchItemByIdentity({ + identity: id, + onItem: function(item){ + store.deleteItem(item); + store.save(); + } + }); + }, + query: function(query, options){ + // summary: + // Queries the store for objects. + // query: Object + // The query to use for retrieving objects from the store + // options: Object? + // Optional options object as used by the underlying dojo.data Store. + // returns: dojo/store/api/Store.QueryResults + // A query results object that can be used to iterate over results. + var fetchHandle; + var deferred = new Deferred(function(){ fetchHandle.abort && fetchHandle.abort(); }); + deferred.total = new Deferred(); + var converter = this._objectConverter(function(object){return object;}); + fetchHandle = this.store.fetch(lang.mixin({ + query: query, + onBegin: function(count){ + deferred.total.resolve(count); + }, + onComplete: function(results){ + deferred.resolve(array.map(results, converter)); + }, + onError: function(error){ + deferred.reject(error); + } + }, options)); + return QueryResults(deferred); + }, + getIdentity: function(object){ + // summary: + // Fetch the identity for the given object. + // object: Object + // The data object to get the identity from. + // returns: Number + // The id of the given object. + return object[this.idProperty]; + } +}); +}); -- cgit v1.2.3