--- /dev/null
+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;
+ }
+});
+
+
+}
projects / eow / blobdiff