Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.data.FlickrRestStore"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.data.FlickrRestStore"] = true;
dojo.provide("dojox.data.FlickrRestStore");

dojo.require("dojox.data.FlickrStore");

dojo.declare("dojox.data.FlickrRestStore",
        dojox.data.FlickrStore, {
        constructor: function(/*Object*/args){ 
                // summary:
                //      Initializer for the FlickrRestStore store.  
                // description:
                //      The FlickrRestStore is a Datastore interface to one of the basic services
                //      of the Flickr service, the public photo feed.  This does not provide
                //      access to all the services of Flickr.
                //      This store cannot do * and ? filtering as the flickr service 
                //      provides no interface for wildcards.
                if(args && args.label){
                        if(args.label) {
                                this.label = args.label;
                        }
                        if(args.apikey) {
                                this._apikey = args.apikey;
                        }
                }
                this._cache = [];
                this._prevRequests = {};
                this._handlers = {};
                this._prevRequestRanges = [];
                this._maxPhotosPerUser = {};
                this._id = dojox.data.FlickrRestStore.prototype._id++;
        },
        
        // _id: Integer
        // A unique identifier for this store.
        _id: 0,
        
        // _requestCount: Integer
        // A counter for the number of requests made. This is used to define
        // the callback function that Flickr will use.
        _requestCount: 0,
        
        // _flickrRestUrl: String
        //      The URL to the Flickr REST services.
        _flickrRestUrl: "http://www.flickr.com/services/rest/",
        
        // _apikey: String
        //      The users API key to be used when accessing Flickr REST services.
        _apikey: null,
        
        // _storeRef: String
        //      A key used to mark an data store item as belonging to this store.
        _storeRef: "_S",
        
        // _cache: Array
        //      An Array of all previously downloaded picture info.
        _cache: null,
        
        // _prevRequests: Object
        //      A HashMap used to record the signature of a request to prevent duplicate 
        //      request being made.
        _prevRequests: null,
        
        // _handlers: Object
        //      A HashMap used to record the handlers registered for a single remote request.  Multiple 
        //      requests may be made for the same information before the first request has finished. 
        //      Each element of this Object is an array of handlers to call back when the request finishes.
        //      This prevents multiple requests being made for the same information.  
        _handlers: null,
        
        // _sortAttributes: Object
        // A quick lookup of valid attribute names in a sort query.
        _sortAttributes: {
                "date-posted": true,
                "date-taken": true,
                "interestingness": true
        },
                        
        _fetchItems: function(request, fetchHandler, errorHandler){
                // summary: Fetch flickr items that match to a query
                // request:
                //      A request object
                // fetchHandler:
                //      A function to call for fetched items
                // errorHandler:
                //      A function to call on error
                var query = {};
                if(!request.query){
                        request.query = query = {};
                } else {
                        dojo.mixin(query, request.query);       
                }
                
                var primaryKey = [];
                var secondaryKey = [];
                
                //Generate a unique function to be called back
                var callbackFn = "FlickrRestStoreCallback_" + this._id + "_" + (++this._requestCount);
                //Build up the content to send the request for.
                var content = {
                        format: "json",
                        method: "flickr.photos.search",
                        api_key: this._apikey,
                        extras: "owner_name,date_upload,date_taken",
                        jsoncallback: callbackFn
                };
                var isRest = false;
                if(query.userid){
                        isRest = true;
                        content.user_id = request.query.userid;
                        primaryKey.push("userid"+request.query.userid);
                }
                if(query.apikey){
                        isRest = true;
                        content.api_key = request.query.apikey;
                        secondaryKey.push("api"+request.query.apikey);
                } else{
                        throw Error("dojox.data.FlickrRestStore: An API key must be specified.");
                }
                request._curCount = request.count;
                if(query.page){
                        content.page = request.query.page;
                        secondaryKey.push("page" + content.page);
                }else if(typeof(request.start) != "undefined" && request.start != null) {
                        if(!request.count){
                                request.count = 20;
                        }
                        var diff = request.start % request.count;
                        var start = request.start, count = request.count;
                        //If the count does not divide cleanly into the start number,
                        //more work has to be done to figure out the best page to request
                        if(diff != 0) {
                                if(start < count / 2) {
                                        //If the first record requested is less than half the amount requested,
                                        //then request from 0 to the count record
                                        count = start + count;
                                        start = 0; 
                                } else {
                                        var divLimit = 20, div = 2;
                                        for(var i = divLimit; i > 0; i--) {
                                                if(start % i == 0 && (start/i) >= count){
                                                        div = i;
                                                        break;
                                                }
                                        }
                                        count = start/div;
                                }
                                request._realStart = request.start;
                                request._realCount = request.count;
                                request._curStart = start;
                                request._curCount = count;
                        } else {
                                request._realStart = request._realCount = null;
                                request._curStart = request.start;
                                request._curCount = request.count;
                        }
                        
                        content.page = (start / count) + 1;
                        secondaryKey.push("page" + content.page);
                }
                if(request._curCount){
                        content.per_page = request._curCount;
                        secondaryKey.push("count" + request._curCount);
                }
                
                if(query.lang){
                        content.lang = request.query.lang;
                        primaryKey.push("lang" + request.lang);
                }
                var url = this._flickrRestUrl;
                
                if(query.setid){
                        content.method = "flickr.photosets.getPhotos";
                        content.photoset_id = request.query.set; 
                        primaryKey.push("set" + request.query.set);
                }
                
                if(query.tags){
                        if(query.tags instanceof Array){
                                content.tags = query.tags.join(",");
                        } else {
                                content.tags=query.tags;                                
                        }
                        primaryKey.push("tags" + content.tags);
                        
                        if(query["tag_mode"] && (query.tag_mode.toLowerCase() == "any"
                                || query.tag_mode.toLowerCase() == "all")){
                                content.tag_mode = query.tag_mode;
                        }
                }
                if(query.text){
                        content.text=query.text;
                        primaryKey.push("text:"+query.text);
                }
                
                //The store only supports a single sort attribute, even though the
                //Read API technically allows multiple sort attributes
                if(query.sort && query.sort.length > 0){                        
                        //The default sort attribute is 'date-posted'
                        if(!query.sort[0].attribute){
                                query.sort[0].attribute = "date-posted";
                        }
                        
                        //If the sort attribute is valid, check if it is ascending or
                        //descending.
                        if(this._sortAttributes[query.sort[0].attribute]) {
                                if(query.sort[0].descending){
                                        content.sort = query.sort[0].attribute + "-desc";
                                } else {
                                        content.sort = query.sort[0].attribute + "-asc";
                                }
                        }
                } else {
                        //The default sort in the Dojo Data API is ascending.
                        content.sort = "date-posted-asc";
                }
                primaryKey.push("sort:"+content.sort);
        
                //Generate a unique key for this request, so the store can 
                //detect duplicate requests.
                primaryKey = primaryKey.join(".");
                secondaryKey = secondaryKey.length > 0 ? "." + secondaryKey.join(".") : "";
                var requestKey = primaryKey + secondaryKey;
                
                //Make a copy of the request, in case the source object is modified
                //before the request completes
                request = {
                        query: query,
                        count: request._curCount,
                        start: request._curStart,
                        _realCount: request._realCount,
                        _realStart: request._realStart,
                        onBegin: request.onBegin,
                        onComplete: request.onComplete,
                        onItem: request.onItem
                };

                var thisHandler = {
                        request: request,
                fetchHandler: fetchHandler,
                errorHandler: errorHandler
                };

                //If the request has already been made, but not yet completed,
                //then add the callback handler to the list of handlers
                //for this request, and finish.
                if(this._handlers[requestKey]){
                this._handlers[requestKey].push(thisHandler);
                return;
                }

                this._handlers[requestKey] = [thisHandler];

                //Linking this up to Flickr is a PAIN!
                var self = this;
                var handle = null;
                var getArgs = {
                        url: this._flickrRestUrl,
                        preventCache: true,
                        content: content
                };
                
                var doHandle = function(processedData, data, handler){
                        var onBegin = handler.request.onBegin;
                        handler.request.onBegin = null;
                        var maxPhotos;
                        var req = handler.request;
                        
                        if(typeof(req._realStart) != undefined && req._realStart != null) {
                                req.start = req._realStart;
                                req.count = req._realCount;
                                req._realStart = req._realCount = null;
                        }

                        //If the request contains an onBegin method, the total number
                        //of photos must be calculated.
                        if(onBegin){
                                if(data && typeof(data.photos.perpage) != "undefined" && typeof(data.photos.pages) != "undefined"){
                                                if(data.photos.perpage * data.photos.pages <= handler.request.start + handler.request.count){
                                                        //If the final page of results has been received, it is possible to 
                                                        //know exactly how many photos there are
                                                        maxPhotos = handler.request.start + data.photos.photo.length;                
                                                }else{
                                                        //If the final page of results has not yet been received,
                                                        //it is not possible to tell exactly how many photos exist, so
                                                        //return the number of pages multiplied by the number of photos per page.
                                                        maxPhotos = data.photos.perpage * data.photos.pages;
                                                }
                                                self._maxPhotosPerUser[primaryKey] = maxPhotos;
                                                onBegin(maxPhotos, handler.request);
                                } else if(self._maxPhotosPerUser[primaryKey]) {
                                        onBegin(self._maxPhotosPerUser[primaryKey], handler.request);
                                }
                        }
                        //Call whatever functions the caller has defined on the request object, except for onBegin
                        handler.fetchHandler(processedData, handler.request);
                        if(onBegin){
                                //Replace the onBegin function, if it existed.
                                handler.request.onBegin = onBegin;
                        }
                };
                
                //Define a callback for the script that iterates through a list of 
                //handlers for this piece of data.  Multiple requests can come into
                //the store for the same data.
                var myHandler = function(data){
                        //The handler should not be called more than once, so disconnect it.
                        //if(handle !== null){ dojo.disconnect(handle); }
                        if(data.stat != "ok"){
                                errorHandler(null, request);
                        }else{ //Process the items...
                                var handlers = self._handlers[requestKey];
                                if(!handlers){
                                        console.log("FlickrRestStore: no handlers for data", data);
                                        return;
                                }

                                self._handlers[requestKey] = null;
                                self._prevRequests[requestKey] = data;

                                //Process the data once.
                                var processedData = self._processFlickrData(data, request, primaryKey);
                                if(!self._prevRequestRanges[primaryKey]) {
                                        self._prevRequestRanges[primaryKey] = [];
                                }
                                self._prevRequestRanges[primaryKey].push({
                                        start: request.start,
                                        end: request.start + data.photos.photo.length
                                });

                                //Iterate through the array of handlers, calling each one.
                                for(var i = 0; i < handlers.length; i++ ){
                                        doHandle(processedData, data, handlers[i]);
                                }
                        }
                };

                var data = this._prevRequests[requestKey];
                
                //If the data was previously retrieved, there is no need to fetch it again.
                if(data){
                        this._handlers[requestKey] = null;
                        doHandle(this._cache[primaryKey], data, thisHandler);
                        return;
                } else if(this._checkPrevRanges(primaryKey, request.start, request.count)) {
                        //If this range of data has already been retrieved, reuse it.
                        this._handlers[requestKey] = null;
                        doHandle(this._cache[primaryKey], null, thisHandler);
                        return;
                }
                
                dojo.global[callbackFn] = function(data){
                        myHandler(data);
                        //Clean up the function, it should never be called again
                        dojo.global[callbackFn] = null;
                };
                                
                var deferred = dojo.io.script.get(getArgs);
                
                //We only set up the errback, because the callback isn't ever really used because we have
                //to link to the jsonFlickrFeed function....
                deferred.addErrback(function(error){
                        dojo.disconnect(handle);
                        errorHandler(error, request);
                });
        },
        
        getAttributes: function(item){
                //      summary: 
                //      See dojo.data.api.Read.getAttributes()
                return ["title", "author", "imageUrl", "imageUrlSmall", 
                                        "imageUrlMedium", "imageUrlThumb", "link",
                                        "dateTaken", "datePublished"]; 
        },
        
        getValues: function(item, attribute){
                //      summary:
                //      See dojo.data.api.Read.getValue()
                this._assertIsItem(item);
                this._assertIsAttribute(attribute);
                if(attribute === "title"){
                        return [this._unescapeHtml(item.title)]; // String
                }else if(attribute === "author"){
                        return [item.ownername]; // String
                }else if(attribute === "imageUrlSmall"){
                        return [item.media.s]; // String
                }else if(attribute === "imageUrl"){
                        return [item.media.l]; // String
                }else if(attribute === "imageUrlMedium"){
                        return [item.media.m]; // String
                }else if(attribute === "imageUrlThumb"){
                        return [item.media.t]; // String
                }else if(attribute === "link"){
                        return ["http://www.flickr.com/photos/" + item.owner + "/" + item.id]; // String
                }else if(attribute === "dateTaken"){
                        return item.datetaken;
                }else if(attribute === "datePublished"){
                        return item.datepublished;
                }
                
                return undefined;
        },

        _processFlickrData: function(/* Object */data, /* Object */request, /* String */ cacheKey){
                // summary: Processes the raw data from Flickr and updates the internal cache.
                // data: 
                //              Data returned from Flickr
                // request: 
                //              The original dojo.data.Request object passed in by the user.
                
                //If the data contains an 'item' object, it has not come from the REST services,
                //so process it using the FlickrStore.
                if(data.items){
                        return dojox.data.FlickrStore.prototype._processFlickrData.apply(this,arguments);
                }

                var template = ["http://farm", null, ".static.flickr.com/", null, "/", null, "_", null];
                
                var items = [];
                if(data.stat == "ok" && data.photos && data.photos.photo){
                        items = data.photos.photo;
                        
                        //Add on the store ref so that isItem can work.
                        for(var i = 0; i < items.length; i++){
                                var item = items[i];
                                item[this._storeRef] = this;
                                
                                template[1] = item.farm;
                                template[3] = item.server;
                                template[5] = item.id;
                                template[7] = item.secret;
                                 
                                var base = template.join("");
                                item.media = {
                                        s: base + "_s.jpg",
                                        m: base + "_m.jpg",
                                        l: base + ".jpg",
                                        t: base + "_t.jpg"
                                };
                        }
                }
                var start = request.start ? request.start : 0;
                var arr = this._cache[cacheKey];
                if(!arr) {
                        this._cache[cacheKey] = arr = [];
                }
                for(var count = 0; count < items.length; count++){
                        arr[count + start] = items[count];
                }

                return arr; // Array
        },
        
        _checkPrevRanges: function(primaryKey, start, count) {
                var end = start + count;
                var arr = this._prevRequestRanges[primaryKey];
                if(!arr) {
                        return false;
                }
                for(var i = 0; i< arr.length; i++) {
                        if(start >= arr[i].start &&
                           end <= arr[i].end) {
                                return true;
                        }
                }
                return false;
        }
});


}