472 lines
14 KiB
JavaScript
472 lines
14 KiB
JavaScript
|
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;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
|
||
|
|
}
|