Changeset 343 for Dev/branches/rest-dojo-ui/client/rft/store.js

Timestamp:

06/18/12 12:51:58 (13 years ago)

Author:

hendrikvanantwerpen

Message:

[Client] Changed store and pages to use CouchDB.
[Client] Disabled login for now, have to figure out some more details about CouchDB.

File:

• Dev/branches/rest-dojo-ui/client/rft/store.js (modified) (1 diff)

Dev/branches/rest-dojo-ui/client/rft/store.js

@@ -1 @@
-define(['dojo/_base/lang','dojo/_base/array','dojo/_base/Deferred','dojo/store/JsonRest','./api'],
-    function(lang,array,Deferred,JsonRest,api){
+define(['dojo/_base/declare','dojo/_base/lang','dojo/_base/array','dojo/_base/Deferred','dojo/_base/xhr','dojo/json','dojo/store/util/QueryResults'],
+    function(declare,lang,array,Deferred,xhr,JSON,QueryResults){
     
-        var OBJ_TYPE = '__objectType';
-        var OBJ_UID = '__objectUid';
-        var REF_TYPE = '__referenceType';
-        var REF_UID = '__referenceUid';
+        var CouchStore = declare("rft.store", null, {
+            /** dojo.Store implementation for CouchDB
+             *
+             * See for details on the REST API, the wiki
+             * at http://wiki.apache.org/couchdb/HTTP_Document_API.
+             */
+                target: "",
+                accepts: "application/json", 
+            idProperty: "_id",
+            revProperty: "_rev",
+            _responseIdProperty: "id",
+            _responseRevProperty: "rev",
+                constructor: function(options){
+                        declare.safeMixin(this, options);
+            },
+                getIdentity: function(object){
+                        return object[this.idProperty];
+            },
+                getRevision: function(object){
+                        return object[this.revProperty];
+            },
+                get: function(id){
+                var dfd = new Deferred();
+                        xhr("GET", {
+                                url: this.target + id,
+                                handleAs: "json",
+                                headers: {
+                                Accept: this.accepts
+                    }
+                        }).then(function(result){
+                    if ( result.error ) {
+                        dfd.reject(result.reason);
+                    } else {
+                        dfd.resolve(result);
+                    }
+                }, function(err){
+                    dfd.reject(err);
+                });
+                return dfd.promise;
+            },
+                put: function(object, options){
+                        options = options || {};
 
-        var RftObject = function(values) {
-            var self = this;
-            lang.mixin(this,values);
-            self.getUid = function() {
-                return self[OBJ_UID];
+                var dfd = new Deferred();
+                        var id = options.id ? options.id : this.getIdentity(object);
+                        var hasId = typeof id != "undefined";
+                        xhr(hasId ? "PUT" : "POST", {
+                                    url: hasId ? this.target + id : this.target,
+                                    postData: JSON.stringify(object),
+                                    handleAs: "json",
+                                    headers:{
+                                            "Content-Type": "application/json",
+                                            Accept: this.accepts
+                                    }
+                            }).then(function(result){
+                    if ( result.error ) {
+                        dfd.reject(result.reason);
+                    } else {
+                        object[this.idProperty] = result[this._responseIdProperty];
+                        object[this.revProperty] = result[this._responseRevProperty];
+                        dfd.resolve(object);
+                    }
+                }, function(err){
+                    dfd.reject(err);
+                });
+                return dfd.promise;
+            },
+                add: function(object, options){
+                return this.put(object,options);
+            },
+                remove: function(id,rev){
+                var dfd = new Deferred();
+                        xhr("DELETE",{
+                                url: this.target + id,
+                                    headers: {
+                        'If-Match': rev
+                    }
+                        }).then(function(result){
+                    if ( result.error ) {
+                        dfd.reject(result.reason);
+                    } else {
+                        dfd.resolve();
+                    }
+                },function(err){
+                    dfd.reject(err);
+                });
+                return dfd.promise;
+            },
+            query: function(query, options){
+                        options = options || {};
+
+                var dfd = new Deferred();
+                var queryOpts = {};
+                if ( query === undefined ) {
+                    query = '_all_docs';
+                    queryOpts.include_docs = true;
+                }
+
+                if (!lang.isString(query)) {
+                    console.warn("Query must be a view name");
+                }
+
+                // Standard options
+                if (options.start >= 0) {
+                    queryOpts.skip = options.start;
+                }
+                if (options.count >= 0) {
+                    queryOpts.limit = options.count;
+                }
+                if (options.sort) {
+                    if (options.sort[0]) {
+                        if (options.sort[0].attribute && options.sort[0].attribute !== "key") {
+                            console.warn("Can only sort on key");
+                        }
+                        if (options.sort[0].descending) {
+                            queryOpts.descending = true;
+                        }
+                    }
+                    if (options.sort.length > 1) {
+                        console.warn("multiple sort fields not supported");
+                    }
+                }
+
+                // Custom options
+                if (options.key) {
+                    queryOpts.key = options.key;
+                } else if (options.keys) {
+                    queryOpts.keys = options.keys;
+                } else if (options.startkey || options.endkey) {
+                    queryOpts.startkey = options.startkey;
+                    queryOpts.endkey = options.endkey;
+                }
+
+                for (var qp in queryOpts) {
+                    queryOpts[qp] = JSON.stringify(queryOpts[qp]);
+                }
+                            query += '?' + xhr.objectToQuery(queryOpts);
+
+                        xhr("GET", {
+                                url: this.target + query,
+                                handleAs: "json",
+                                headers: {
+                        Accept: this.accepts
+                    }
+                        }).then(function(result){
+                    if (result.error) {
+                        dfd.reject(result.reason);
+                    } else  {
+                        dfd.resolve(
+                            array.map(result.rows,
+                                      function(result){ return result.value; }));
+                    }
+                },function(err){
+                    dfd.reject(err);
+                });
+                        return QueryResults(dfd.promise);
             }
-        };
-    
-        var rftStoreCtor = function(objectType) {
-            var jsonStore = new JsonRest({
-                target:"../server/api.php/data/"+objectType+"/",
-                idProperty: OBJ_UID
-            });
-            var errHandler = api.defaultErrorHandler;
-            return lang.delegate(jsonStore,{
-                query: function(query, directives){
-                    return Deferred.when( jsonStore.query(query,directives), function(results){
-                        return array.map(results,function(result){
-                            return new RftObject(typeof result == "object" ? result : object);
-                        });
-                    },errHandler);
-                },
-                get: function(id, directives){
-                    return Deferred.when( jsonStore.get(id,directives), function(result){
-                        return new RftObject(typeof result == "object" ? result : object);
-                    },errHandler);
-                },
-                add: function(object, directives){
-                    return Deferred.when( jsonStore.add(object,directives), function(result){
-                        return new RftObject(typeof result == "object" ? result : object);
-                    },errHandler);
-                },
-                put: function(object, directives){
-                    return Deferred.when( jsonStore.put(object,directives), function(result) {
-                        return new RftObject(typeof result == "object" ? result : object);
-                    },errHandler);
-                },
-                remove: function(id, directives){
-                    return jsonStore.remove(id,directives);
-                }
-            });
-        };
-    
-        var storeCache = {};
-    
-        return {
-            getStore: function(objectType) {
-                if ( !storeCache[objectType] ) {
-                    storeCache[objectType] = new rftStoreCtor(objectType);
-                }
-                return storeCache[objectType];
-            },
-            dereference: function(object) {
-                if ( object[REF_TYPE] ) {
-                    return this.getStore(object[REF_TYPE]).get(object[REF_UID]);
-                }
-                return object;
-            }
-        };
+        });
+
+        return new CouchStore({target: '/couchdb/rft/'});
 
     });