source: Dev/branches/rest-dojo-ui/client/rft/store.js @ 362

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 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 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(lang.hitch(this,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';
                }

                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 !== undefined) {
                    queryOpts.key = options.key;
                } else if (options.keys !== undefined) {
                    queryOpts.keys = options.keys;
                } else if (options.startkey !== undefined || options.endkey !== undefined) {
                    queryOpts.startkey = options.startkey;
                    queryOpts.endkey = options.endkey;
                }
                if (options.include_docs !== undefined) {
                    queryOpts.include_docs = options.include_docs;
                }
                if (options.reduce !== undefined) {
                    queryOpts.reduce = options.reduce;
                }
                if (options.group !== undefined) {
                    queryOpts.group = options.group;
                    if (options.group_level !== undefined) {
                        queryOpts.group_level = options.group_level;
                    }
                }

                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.key, options.include_docs === true ? result.doc : result.value];
                                      }));
                    }
                },function(err){
                    dfd.reject(err);
                });
                        return CouchResults(dfd.promise);
            }
        });

        function CouchResults(results) {
            if (!results) {
                return results;
            }

                if(results.then){
                        results = lang.delegate(results);
                }

            if (!results.forEach) {
                results.forEach = function(callback) {
                    return Deferred.when(results, function(results) {
                        array.forEach(results, function(result) {
                            callback(result[1],result[0]);
                        });
                    });
                }
            }

            return results;
        }

        return new CouchStore({target: 'data/rft/'});

    });