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

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(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){
                 // summary:
                 //     put an object in CouchDB
                 // object: Object
                 //     The object to put
                 // options: Object
                 //     Options object as
                 //         id: String
                 //
                        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){
                // summary:
                //    query a couchdb view
                // query: String
                //    name of a couchdb view you want to query, relative to the current database
                // options: Object
                //     options object as
                //        start: Number
                //            Start results at this item
                //        count: Number
                //            Number of items to return
                //        sort: [{attribute:'key',descending:true|false}]
                //            CouchDB only support sorting by key, so only 'key'
                //            is allowed as attribute value. Multiple sort items
                //            are ignored.
                //        key: String|Array|Object
                //            Return only values with this key.
                //            Excludes start/endkey usage.
                //        startkey: String|Array|Object
                //            Return values starting from this key.
                //        endkey: String|Array|Object
                //            Return values with key lower than this key.
                //        include_docs: true|false
                //            Return the full documents instead of the view
                //            values.
                //        reduce: true|false
                //            Execute reduce on the view or not. Default depends
                //            on if a reduce function is defined on the view.
                //        group: true|false
                //            Should values be grouped per key or not? Default
                //            is false.
                //        group_level: Number
                //            When group = true and the key is an array,
                //            determines which elements starting from the first
                //            are used for grouping. Default is 0.
                //        get_keys: true|false
                //            Instead of returning the values or documents,
                //            return the array of keys as the result.
                //            This does not affect the forPairs function.
                        options = options || {};

                var dfd = new Deferred();
                var queryOpts = {};
                if ( !query ) {
                    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  {
                        var results;
                        var values = array.map(result.rows,function(result){
                            return options.include_docs === true ? result.doc : result.value;
                        });
                        var keys = array.map(result.rows,function(result){
                            return result.key;
                        });
                        if (options.get_keys === true) {
                            results = keys;
                            results.values = values;
                        } else {
                            results = values;
                            results.keys = keys;
                        }
                        dfd.resolve(results);
                    }
                },function(err){
                    dfd.reject(err);
                });
                        return CouchResults(dfd.promise);
            }
        });

        function CouchResults(results) {
            results = QueryResults(results);
            results.forPairs = function(callback,thisObject) {
                callback = lang.hitch(thisObject,callback);
                return Deferred.when(results,function(results) {
                    var values = results.values || results;
                    var keys = results.keys || results;
                    return array.forEach(values, function(value,index) {
                        callback(value,keys[index],index);
                    });
                });
            }
            return results;
        }

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

    });