/**
* Copyright 2009 Lime Labs LLC
*
* This file is part of AXIS.
*
* AXIS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 3 as published by the Free Software Foundation.
*
* AXIS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with AXIS. If not, see .
*/
/**
* @fileoverview
*
* CustomEvents
*
* Allows the creation of custom events which can be subscribed to and fired.
*
* @requires AXIS
*/
function CustomEvents()
{
/**
* @constructor
*/
this.__construct = function()
{
};
/**
* Creates a subscribable event.
*
* @param {Object} ob Object of form:
* {
* {String} name Name of event.
* {Object} [scope] Scope to fire subscrber handler in. Default window.
* }
*/
this.create = function(ob)
{
var d = ob || {};
d.name = d.name || '';
d.scope = d.scope || window;
/**
* Note that there is a closure on d.name throughout the method definitions
* for the custom object defined below.
*/
var evOb = function()
{
this._subscribers = [];
this._hasFired = false;
this._scope = d.scope;
this._name = d.name;
};
evOb.prototype =
{
/**
* Subscribes to an event.
*
* @param {Object} ob Object of form:
* {
* {Function} callback Function to call when event fires.
* {Object} [object] Scope to fire subscrber handler in. Default window.
* }
*/
subscribe: function(ob)
{
var b = ob || {};
b.callback = b.callback || AXIS.F;
b.object = b.object || {};
b.wait = b.wait || false;
this._subscribers.push(b);
if(this._hasFired && (b.wait === false))
{
b.callback.apply(this._scope,this._hasFired);
}
},
fire: function(a)
{
var fR;
var args = a || [];
/**
* @see #subscribe
* @see #hasFired
*/
this._hasFired = args;
for(var f=0; f < this._subscribers.length; f++)
{
ss = this._subscribers[f];
ss.callback.apply(this._scope,args.concat([this._name, ss.object]));
}
},
hasFired: function()
{
return this._hasFired;
}
};
return new evOb;
};
};
/**
* Copyright 2008, 2009 Lime Labs LLC
*
* This file is part of AXIS.
*
* AXIS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 3 as published by the Free Software Foundation.
*
* AXIS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with AXIS. If not, see .
*/
/**
* @fileoverview
*/
function Util()
{
/**
* @constructor
*/
this.__construct = function()
{
AXIS.onContentReady(function(){
var limefooter = document.getElementById('limefooter');
if (limefooter == null)
return;
var get_bit_link = limefooter.getElementsByTagName('span')[0];
if (get_bit_link) {
get_bit_link = get_bit_link.getElementsByTagName('a')[0];
AXIS.attachEvent('click', function(e) {
if (!e.preventDefault) {
e.returnValue = false;
}
else {
e.preventDefault();
}
var bitPath;
if (this.getAttribute) {
bitPath = this.getAttribute('bitPath') || location.pathname;
}
else {
bitPath = location.pathname;
}
AXIS.Util.bit.getBit(bitPath);
}, get_bit_link);
}
if (AXIS._siteData.hosts.limebits == 'http://www.limebits.com/')
return;
var footer_links = limefooter.getElementsByTagName('a');
for (var i = 0; i < footer_links.length; i++)
{
var href = footer_links[i].href;
if (href.match(/http:\/\/[^\.]*.limebits.com\//))
footer_links[i].href = href.replace('limebits.com', AXIS._siteData.hosts.limebits.match(/http:\/\/www\.([^\/]*)\//)[1]);
}
});
};
this.bit =
{
getBit: function(bitPath)
{
var bit_folder = bitPath.match(/.*\//)[0]; // match till the last folder in the path
bit_folder = bit_folder.replace(/(\/*)$/, ''); // get rid of the trailing '/'
var bit_folder_name = bit_folder.replace( /.*\//, "" );
var bit_file = bitPath.replace( /.*\//, "" ); // get the basename
var user = AXIS.Cookies.read('user');
if (AXIS._siteData.hosts.limebits != ("http://" + location.host + "/"))
{
return;
}
if (user)
{
var dst_folder = '/home/' + user;
AXIS.WebDAV.COPY({
url: bit_folder,
destination: dst_folder + '/' + bit_folder_name,
tryAlternateNames: true,
on201: function(r) {
if (r.alternateName) {
bit_folder_name = r.alternateName;
}
var dst_url = AXIS._siteData.hosts.limebits.replace("http://www.", "http://" + user + ".") + bit_folder_name + "/" + bit_file;
AXIS.Cookies.create(dst_url, "new_copy", { path: '/apps/bar' });
top.location = dst_url + "?bar";
}
});
}
else
{
var rand = "" + Math.random();
AXIS.Cookies.create(rand, bitPath, { path: '/apps/bar' });
AXIS.Login.redirReturnTo = AXIS._siteData.hosts.limebits + 'apps/bar/copy_proxy.html#' + rand;
AXIS.Login._redirectToAccess("if_new");
}
}
}
this.uri =
{
basename: function(path)
{
return path.replace(/.*\//, "");
},
/* get folder containing given URL,
* will return the URL itself if it ends in '/'
* otherwise strips all non '/' characters at the end */
getFolder: function(url) {
return url.replace(/\/[^\/]*$/,'/');
},
getParent: function(url) {
return url.replace(/\/[^\/]*\/?$/, '/');
},
findAlternateName: function(name, used_names)
{
if (!used_names.indexOf)
{
used_names.indexOf = function(item)
{
for (var i = 0; i < this.length; i++)
if (this[i] === item) return i;
return -1;
}
}
var new_name, extension;
if (name.indexOf('.') == -1)
{
new_name = name;
extension = '';
}
else
{
var name_parts = name.match(/(.*)(\.[^.]*)$/);
new_name = name_parts[1];
extension = name_parts[2];
}
var start_num = 2;
var name_parts = new_name.match(/(.*)([\d]+)$/);
if (name_parts)
{
new_name = name_parts[1];
start_num = parseInt(name_parts[2]) + 1;
}
var new_full_name;
var end_num = start_num + used_names.length + 1;
for (var i = start_num; i <= end_num; i++)
{
var new_full_name = new_name + i + extension;
if (used_names.indexOf(new_full_name) == -1) break;
}
return new_full_name;
}
};
this.xml =
{
iterableToArray: function(iterable) {
if (iterable.toArray) return iterable.toArray();
var length = iterable.length, results = new Array(length);
while (length--) results[length] = iterable[length];
return results;
},
getChildrenByNameNS: function(el, name, ns) {
if (ns == null)
ns = "DAV:";
if (typeof el.getElementsByTagNameNS == "function")
return this.iterableToArray(el.getElementsByTagNameNS(ns, name));
else {
el.ownerDocument.setProperty("SelectionLanguage", "XPath");
el.ownerDocument.setProperty("SelectionNamespaces", "xmlns:pref='"+ns+"'");
var child_els = el.selectNodes("*//pref:" + name);
if (child_els.length == 0)
child_els = el.selectNodes("pref:" + name);
return this.iterableToArray(child_els);
}
},
getText: function(node)
{
var txt = "";
for (var i = 0; i < node.childNodes.length; i++)
{
if (node.childNodes[i].nodeType == AXIS.TEXT_NODE)
txt += node.childNodes[i].nodeValue;
}
return txt;
}
}
this.lang =
{
augmentObject: function(r, s) {
for(var p in s)
{
r[p] = s[p];
}
}
}
}
/**
* Copyright 2008, 2009 Lime Labs LLC
*
* This file is part of AXIS.
*
* AXIS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 3 as published by the Free Software Foundation.
*
* AXIS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with AXIS. If not, see .
*/
/**
* @fileoverview
*/
function Cookies()
{
/**
* @constructor
*/
this.__construct = function()
{
};
this.create = function(name,value,o)
{
o = o || {};
name = encodeURIComponent(name);
value = encodeURIComponent(value);
o.path = o.path || "/";
if(o.days)
{
var date = new Date();
date.setTime(date.getTime()+(o.days*24*60*60*1000));
var expires = "; expires="+date.toGMTString();
}
else
{
var expires = "";
}
try
{
document.cookie = name+"="+value+expires+"; path="+o.path;
return true;
}
catch(e)
{
return false;
}
};
this.update = function(name,value,days)
{
/*
* bridge function to allow more accurate
* description of script flow
*/
var n = name || null;
var v = value || null;
var d = days || null;
return this.create(n,v,d);
};
this.read = function(name)
{
var nameEQ = encodeURIComponent(name) + "=";
var ca = document.cookie.split(';');
for(var i=0;i < ca.length;i++)
{
var c = ca[i];
while(c.charAt(0)==' ')
{
c = c.substring(1,c.length);
}
if(c.indexOf(nameEQ) == 0)
{
return decodeURIComponent(c.substring(nameEQ.length,c.length));
}
}
return false;
};
this.erase = function(name, o)
{
o = o || {};
o.days = -1;
return this.create(name,"", o);
};
};/**
* Copyright 2008, 2009 Lime Labs LLC
*
* This file is part of AXIS.
*
* AXIS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 3 as published by the Free Software Foundation.
*
* AXIS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with AXIS. If not, see .
*/
/**
* @fileoverview
*
* @requires AXIS
* @requires Cookies
*/
function User()
{
/**
* @constructor
*/
this.__construct = function()
{
};
/**
* Loads a client's geodata, via Google's Data API.
* Note that this is making an XHR call, so the data
* will be available at some point in the future -- it is likely
* that you would want to set a callback to inform your application
* of when this data is available.
*
* @param {Function} [cb] The callback function.
* @example AXIS.User.getUserGeoData(function() {
* alert(AXIS.User.Data.get('city'));
* });
*/
this.getUserGeoData = function(cb)
{
if(AXIS.Modules)
{
AXIS.Modules.load({
provider: 'google',
module: 'gdata',
version: '1',
options:
{
callback: function()
{
var v = google.loader.ClientLocation;
var a = v.address;
var d = AXIS.User.Data;
d.set('latitude', v.latitude || '');
d.set('longitude', v.longitude || '');
d.set('city', a.city || '');
d.set('country', a.country || '');
d.set('country_code', a.country_code || '');
d.set('region', a.region || '');
cb && cb();
}
}
});
}
};
this.Data =
{
set: function(k,v)
{
if(k && v)
{
this[k] = v;
}
},
get: function(k)
{
if(k && this[k])
{
return this[k];
}
else
{
return false;
}
}
};
/*
* Checks if user is logged in by reading cookie ('user');
* NOTE: use #username if possible.
*
* @return {Mixed} username if logged in; {Boolean} false if not
*/
this.isLoggedIn = function()
{
return AXIS.Cookies.read('user');
};
/**
* Alias of #isLoggedIn: more readable.
*
* @return {String} username if logged in; 'unauthenticated' if not
*/
this.username = function()
{
return AXIS.Cookies.read('user') || 'unauthenticated';
};
};/**
* Copyright 2008, 2009 Lime Labs LLC
*
* This file is part of AXIS.
*
* AXIS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 3 as published by the Free Software Foundation.
*
* AXIS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with AXIS. If not, see .
*/
/**
* @fileoverview
*/
function Loader()
{
/**
* @constructor
*/
this.__construct = function()
{
/*
* all requests will go into _activeRequests until a locked request.
* TODO: create locked requests, and request queueing
*/
this._activeRequests = [];
AXIS.onContentReady(function()
{
this.loadingPanel = document.body;
this.createLoadingPanel();
},this);
/*
* 1: Supported by all browsers
* 2: Supported by rfc2616 (Opera supports these)
* 3: Basic methods, supported by IE.
* n: Gecko(Firefox) supports all methods
*
* NOTE: methods of higher index include all lower indexed methods
*/
this.supportedMethods = {
GET: 1,
POST: 1,
HEAD: 2,
PUT: 2,
DELETE: 2,
PROPFIND: 3,
PROPPATCH: 3,
MKCOL: 3,
LOCK: 3,
UNLOCK: 3,
COPY: 3,
MOVE: 3,
REPORT: 3,
SEARCH: 3,
CHECKIN: 3,
CHECKOUT: 3,
'VERSION-CONTROL': 3
};
};
/**
* Use this method to initiate an XHR call, mainly if you simply want to
* fetch a resource using GET. A more comprehensive API for sending various
* types of HTTP calls can be found in AXIS#WebDAV. A direct call using this
* method would look like:
*
* AXIS.Loader.load({url: foo/bar.html});
*
* NOTE: default method is GET; and TRUE is the default for .asynch property.
*/
this.load = function(a)
{
/*
* Validate "core" attributes
*/
if(!!a.url === false)
{
AXIS.Errors.catchError(new Error('XHR_NO_URL_SENT'));
return false;
}
a.method = (a.method) ? a.method.toUpperCase() : 'GET';
a.url = a.url;
a.callback = a.callback || AXIS.F;
a.onBeforeSend = a.onBeforeSend || AXIS.F;
a.onAfterSend = a.onAfterSend || AXIS.F;
a.onSuccess = a.onSuccess || AXIS.F;
a.onFailure = a.onFailure || AXIS.F;
a.callId = a.callId || AXIS.getUniqueId('xhr_');
a.passThru = a.passThru || [];
a.asynch = (a.asynch === undefined) ? false : !!a.asynch;
a.body = a.body || null;
a.username = a.username || null;
a.password = a.password || null;
a.loadingMsg = a.loadingMsg || AXIS.defaultLoadingMsg;
a.headers = a.headers || {};
/**
* To simplify matters for user, allow the sending of succ/fail codes in
* basic array format ( [403,412,423] ). However, we'll want to look
* them up as keys (codes[200] === true). So translate here.
*
* @see XMLHTTP#build#main
*/
a.failureCodes = a.failureCodes || [];
for(var f=0; f.
*/
/**
* @fileoverview
*
* The main routines for XHR. The main purpose is to provide methods to build
* and enhance the transport package, make the call, check status and throw
* transport errors.
*
* @throws Error XHR_401
* @throws Error XHR_423
* @throws Error XHR_500
* @requires AXIS
*/
function XMLHTTP()
{
/**
* @constructor
*/
this.__construct = function()
{
/**
* The headers that will be sent with every request, unless overridden
*
* @see #send
*/
this.defaultHeaders =
{
'X-Requested-With': 'XMLHttpRequest',
'Content-Type': 'text/html'
};
/**
* Caching information and storage for GET calls.
*
* @see #send
* @see #build#main
*/
this.cache = {};
/**
* The receipt of a status code *not* present in this list results
* in the call being treated as failed.
*
* NOTE: the `reshuffling` done on this Array following definition.
*
* @see #build
*/
this.statusCodes =
[
100, // Continue
102, // Processing (WebDAV) (RFC 2518)
200, // OK
201, // Created
202, // Accepted
203, // Non-Authoritative Information (since HTTP/1.1)
204, // No Content
205, // Reset Content
206, // Partial Content
207, // Multi-Status (WebDAV)
208, // Already reported.
300, // Multiple Choices
301, // Moved Permanently
302, // Found
303, // See Other (since HTTP/1.1)
304, // Not Modified
305, // Use Proxy (since HTTP/1.1)
307, // Temporary Redirect (since HTTP/1.1)
400, // Bad Request
401, // Unauthorized
402, // Payment Required
403, // Forbidden -- Note Opera will often return this instead of 401
404, // Not Found
405, // Method Not Allowed
406, // Not Acceptable
407, // Proxy Authentication Required
408, // Request Timeout
409, // Conflict
410, // Gone
411, // Length Required
412, // Precondition Failed
413, // Request Entity Too Large
414, // Request-URI Too Long
415, // Unsupported Media Type
416, // Requested Range Not Satisfiable
417, // Expectation Failed
422, // Unprocessable Entity (WebDAV) (RFC 4918)
423, // Locked (WebDAV) (RFC 4918)
424, // Failed Dependency (WebDAV) (RFC 4918)
426, // Upgrade Required (RFC 2817)
449, // Retry With
500, // Internal Server Error
501, // Not Implemented
502, // Bad Gateway
503, // Service Unavailable
504, // Gateway Timeout
505, // HTTP Version Not Supported
506, // Loop detected (Bind Draft)
507, // Insufficient Storage (WebDAV) (RFC 4918)
509, // Bandwidth Limit Exceeded
510 // Not Extended (RFC 2774)
];
/**
* Create another accessor, creating object properties from values
* (allowing checks for statusCodes[sc])
*/
var i = this.statusCodes.length;
while(i--)
{
this.statusCodes[this.statusCodes[i]] = this.statusCodes[i];
}
};
/**
* It is often the case that an API will set status code handlers
* for HTTP responses (on404, on200, etc). As well, it is common
* for several of these to be set per response. This function aims
* to make that process easier, allowing the developer to send a status
* code and either a handler function or an AXIS.Errors code (which is
* then translated into a function which fires an error notification). As
* well, the developer can set more than one of these to set at a time.
* Function must be called status:function||code pairs, such as:
* AXIS.XMLHTTP.setStatusHandlerForResponse(xmlhttprespobj,
* {
* 200: function(){ // do something },
* 404: 'AXIS_ERROR_CODE'
* }
* Notice as well that should there already is a handler, it is not overridden.
*
* @param {Object} o The returned object from AXIS#XMLHTTP#send
* @param {Object} i The handler info
*
* @see AXIS#WebDAV
*/
this.setStatusHandlerForResponse = function(o,i)
{
var f = i || {};
var n = function(t,ns,nf)
{
t['on' + ns] = t['on' + ns] || (nf[ns].constructor === String) ? function()
{
AXIS.Errors.catchError(new Error(nf[ns]));
} : nf[ns];
}
for(var s in f)
{
n(o || {},s,f);
}
};
/**
* Use this to override the default headers for XHR object, or to set others.
*/
this.setRequestHeader = function(xhr,nm,hd)
{
xhr.httpHandle.setRequestHeader(nm, hd);
};
/**
* Will set default headers for the call object (see #XMLHTTP). NOTE that
* should an equivalent header be set in the call object, the default will
* of course not override it.
*/
this.setDefaultHeaders = function(xhr)
{
var ch = xhr.headers;
for(var h in this.defaultHeaders)
{
if(!ch[h])
{
this.setRequestHeader(xhr, h, this.defaultHeaders[h]);
}
}
};
/**
* Constructs an XHR object. It is built to be attached to AXIS#Queue
*
* {@link AXIS#Queue}
* @return An extended XHR object
* @type Object
*/
this.build = function(a)
{
var xob =
{
httpHandle: window.ActiveXObject ? new ActiveXObject("Msxml2.XMLHTTP") : new XMLHttpRequest(),
/**
* Interprets the .status property of this.httpHandle, adjusting
* for various quirks, only allowing acceptable codes, warning if
* errors happen.
*
* @see #main
* @return False on error, a number if successful
* @type Mixed
*/
getStatus: function()
{
var hh = this.httpHandle;
//alert('stat:' + hh.status);
/*
* TODO: testing xbrow
*/
if((!hh.status && location.protocol == 'file:') || hh.status)
{
/**
* Check for IE oddity of creating status `1223` when
* correct is `204`. Simply return reset value
*/
if(hh.status == 1223)
{
return 204;
}
/**
* @see XMLHTTP#XMLHTTP#statusCodes
*/
if(hh.status == 403 && AXIS.isOpera)
{
return 401;
}
/**
* Only return on acceptable status codes
*/
if(AXIS.XMLHTTP.statusCodes[hh.status])
{
return hh.status;
}
}
return false;
},
lifespan: a.lifespan || AXIS._maxXHRLifespan,
onBeforeDie: a.onBeforeTimeout || function()
{
AXIS.Errors.catchError(new Error('XHR_REQUEST_TIMEOUT'))
},
/**
* The XHR object should be attached to the AXIS.Queue, and
* will wait for the readyState to hit `4`.
*
* .readyState values:
* 0: uninitialized
* 1: loading
* 2: loaded
* 3: interactive
* 4: complete
*
* {@link Queue}
* @type Boolean
*/
main: function()
{
/**
* Synch calls, which block, can only reach here after .main() is
* called, which must be after the block. So we know, if synch, that
* we have a response, and don't need to check readyState. This also
* fixes issues with Safari and perhaps some other browsers and how
* they may or may not properly handle .readyState when using synch.
*/
if((this.httpHandle.readyState == 4) || (this.asynch === false))
{
var T = this;
/**
* Ensure that we snip this instance off the queue, in case
* of some error happening where the main function fails
* to return false. NOTE: relevant only to asynch calls (Queue)
*/
this.die && this.die();
/**
* Handles the loading notifications cleanup
*/
AXIS.Loader.afterResponseCleanup(T);
var stat = T.getStatus();
T.responseText = T.httpHandle.responseText || '';
T.responseXML = '';
if(T.httpHandle.responseXML)
{
T.responseXML = T.httpHandle.responseXML;
T.serializedXML = function()
{
return AXIS.isIE ? this.responseXML.xml : (new XMLSerializer()).serializeToString(this.responseXML);
}
}
if(stat == 304)
{
/**
* Not modified response is 304; in those cases we want to send back
* the cached version, if any, to the callback. So we first make sure we handle
* the 304 (to replace current response with cached response). The callback also
* needs to be modified, in order to provide caching for fresh responses.
*/
//alert('304: '+T.url);
try
{
var cac = AXIS.XMLHTTP.cache[T.url];
T.responseText = cac.responseText;
T.responseXML = cac.responseXML;
}
catch(e)
{
alert('cache error');
}
}
else if(stat === 200 && T.method === 'GET') // only cache successful GET's
{
/**
* On first load, cache info.
* Fetch the Etag and use to store match flag.
* Unfortunately response header not always available on all browsers.
*/
try
{
T.__ETAG__ = T.httpHandle.getResponseHeader("Etag");
}
catch(e)
{
T.__ETAG__ = '"0"';
}
AXIS.XMLHTTP.cache[T.url] = T;
}
/**
* Call the response processor, if any. Note that this will be returned
* as the second argument of a response handler.
*/
var procResp = T.responseProcessor
? T.responseProcessor.call(T.scope, T)
: false;
/**
* NOTE how we call onXXX handlers prior to other response handlers.
*/
T['on' + stat] && T['on' + stat].call(T.scope, T, procResp);
/**
* Various status code checking, errors, successes, etc.
*/
if((stat === false) || T.failureCodes[stat])
{
T.onFailure.call(T.scope, T, procResp);
}
/**
* Check for special status errors. These are critical errors that
* should not happen, or are worthy of ensuring that the user is notified
* of their occurrence (ie. 401). If the user has defined an error handler
* for the specified status codes, that is handled below.
*/
else if( (stat == 401)
||(stat == 423)
||(stat >= 500))
{
/**
* Do not fire default errors if user has own handler
*/
if(!T['on' + stat])
{
AXIS.Errors.catchError(new Error('XHR_' + stat + '~~' + T.url));
}
T.onFailure.call(T.scope, T, procResp);
}
/**
* A call is successful only if it satisfies this conditional.
*/
else if( ((stat > 199)
&&(stat < 209))
|| stat == 304
||T.successCodes[stat])
{
T.onSuccess.call(T.scope, T, procResp);
}
/**
* NOTE: .callback is always called whether success or failure, useful
* for creating a single handler.
*/
T.callback.call(T.scope, T, procResp);
return procResp || T;
}
return true;
}
};
/**
* Now attach request args to the returned object
*/
for(var p in a)
{
xob[p] = a[p];
}
xob.httpHandle.onreadystatechange = AXIS.F;
return(xob);
};
this.send = function(a)
{
var CB = this.build(a);
CB.onBeforeSend();
/**
* This scope will be applied to the response handlers, if any.
*
* @see #build#main
*/
CB.scope = CB.scope || CB;
CB.httpHandle.open(CB.method,CB.url,CB.asynch,CB.username,CB.password);
this.setDefaultHeaders(CB);
/*
* GET requests should not send content-type header
*/
if(CB.method == 'GET')
{
if(CB.headers["Content-Type"])
{
delete CB.headers["Content-Type"];
}
/**
* Using Etag to check for changes in file, for cacheing. See #build#main
*/
CB.headers["If-None-Match"] = (this.cache[CB.url]) ? this.cache[CB.url].__ETAG__ : '"0"';
}
/**
* Override default headers with any sent in call object
*/
if(CB.headers)
{
for(var z in CB.headers)
{
this.setRequestHeader(CB, z, CB.headers[z]);
}
}
CB.httpHandle.send(CB.body);
CB.onAfterSend();
return(CB);
};
};
/**
* Copyright 2008, 2009 Lime Labs LLC
*
* This file is part of AXIS.
*
* AXIS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 3 as published by the Free Software Foundation.
*
* AXIS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with AXIS. If not, see .
*/
/**
* @fileoverview
*
* This is a collection of WebDAV methods. This is a core class, part of the
* AXIS framework. All functions or calls which have to do with WebDAV operations
* are included here.
*
* @href http://greenbytes.de/tech/webdav/rfc4918.html
*
* Dead Properties
* ---------------
* creationdate
* displayname
* getcontentlanguage
* getcontentlength
* getcontenttype
* getetag
* getlastmodified
* lockdiscovery
* resourcetype
* supportedlock
*
* @requires AXIS
* @requires Loader
* @throws DAV_MOVE_403
* @throws DAV_MOVE_404
* @throws DAV_MOVE_409
* @throws DAV_MOVE_412
* @throws DAV_COPY_403
* @throws DAV_COPY_404
* @throws DAV_COPY_409
* @throws DAV_COPY_412
* @throws DAV_PUT_NO_BODY
* @throws DAV_DELETE_404
* @throws DAV_BAD_PROPSET_ARGS
* @throws DAV_BAD_PROPREMOVE_ARGS
* @throws DAV_LOCK_412
* @throws DAV_UNLOCK_400
* @throws DAV_UNLOCK_403
* @throws DAV_UNLOCK_409
* @throws DAV_NO_RANGE
*
*/
function WebDAV()
{
/**
* @constructor
*/
this.__construct = function()
{
this.currentProperties = [];
/**
* Default headers for all DAV calls.
*
* @see #_prepare
*/
this.defaultHeaders =
{
'Content-type': 'application/xml; charset="utf-8"',
'X-Requested-With': "XMLHttpRequest"
};
/**
* In seconds.
*
* @see #LOCK
*/
this._defaultLOCKTimeout = 86400;
/**
* Only write is supported.
*
* @see #LOCK
*/
this._defaultLOCKType = 'write';
/**
* @see #LOCK
*/
this._defaultLOCKScope = 'exclusive';
/**
* @see #LOCK
*/
this._defaultLOCKDepth = 'infinity';
this.PRINCIPAL_ALL = '1';
this.PRINCIPAL_AUTHENTICATED = '2';
this.PRINCIPAL_UNAUTHENTICATED = '3';
this.PRINCIPAL_SELF = '4';
this.PRINCIPAL_PROPERTY = '5';
this.PRINCIPAL_USER = '6';
this.PRINCIPAL_GROUP = '7';
this.PRINCIPAL_HREF = '8';
// run this anonymous function immediately to create the operators to be used in search
(function() {
var search = this.SEARCH;
search._prop_to_xml = function (prop) {
if (prop.constructor != Array) {
prop = [prop];
prop.unshift("DAV:") // set dav as default if no namespace is present
}
return '';
};
// logical operators
var logicalOps = ["and", "not", "or"];
var logialGenerator = function(oper) {
search[oper] = function() {
return "<" + oper +">" + Array.prototype.join.call(arguments, "") + "";
}
}
for (var i=0; i < logicalOps.length; i++) {
logialGenerator(logicalOps[i])
};
// comparison operators
var comparisonOps = ["gt", "lt", "eq", "gte", "lte", "gti", "lti", "like", "is_defined", "is_collection"];
var comparisonGenerator = function(oper) {
search[oper] = function(prop, literal) {
if (oper === "is_defined")
return "" + search._prop_to_xml(prop) + "";
if (oper === "is_collection")
return "";
if (literal !== undefined) {
if (oper.indexOf("i") === (oper.length - 1)) {
oper = oper.slice(0, -1);
literal = '' + literal + "";
} else {
literal = "" + literal + "";
}
}
return "<" + oper + ">" + search._prop_to_xml(prop) + "" + literal + "";
}
}
for (var i=0; i < comparisonOps.length; i++) {
comparisonGenerator(comparisonOps[i])
};
}).apply(this);
};
/**
* This is where the storage and organization of locks is handled.
* The general idea is that given a resource url, a user, a locktype,
* and a locktoken, we can uniquely identify a lock.
*/
this.Locks =
{
_locks: [],
/**
* Store lock info on successful lock.
*
* @param {Object} s An option object containing the .url, the .owner,
* the .token and the .locktype for this lock. All
* required. Note that there is additional info passed
* by WebDAV#LOCK which may be useful.
* @type {Boolean}
* @see WebDAV#LOCK
*/
store: function(s)
{
if( s.url
&& s.owner
&& s.locktype
&& s.locktoken)
{
/**
* There isn't a problem if the lock exists already. There isn't
* any harm in re-storing (we already have all calculated values and
* a consistent key, and this function is not run extensively, expensively),
* so just (re)build the store.
*/
this._locks[s.locktoken] = s;
return true;
}
else
{
AXIS.Errors.catchError('DAV_BAD_LOCK_ARGS');
return false;
}
},
/**
* Get lock info for a key.
*
* @param {String} k A locktoken
* @returns An object containing values for lock, or false if none.
* @type {Mixed}
*
* @see WebDAV#Locks#store
*/
fetch: function(k)
{
if(k)
{
return this._locks[k];
}
return false;
},
/**
* Remove lock info for a key.
*
* @param {String} k A locktoken
* @returns Nothing.
*
* @see WebDAV#Locks#store
*/
remove: function(k)
{
if(k && this._locks[k])
{
delete this._locks[k];
}
},
/**
* Get lock info for ALL locks stored containing a given property.
*
* @param {String} p A lock property, one of those sent to WebDAV#Locks#store
* @param {String} v The value to search for on `p` property
* @returns All objects containing that property, or an empty array.
*
* @type {Array}
*
* @see WebDAV#Locks#store
*/
fetchByPropValue: function(p,v)
{
var retArr = [];
var curL;
if(p)
{
for(var w in this._locks)
{
curL = this._locks[w];
if(curL[p] == v)
{
retArr.push(curL);
}
}
}
return retArr;
}
};
/**
* MAIN WEBDAV METHODS
* These methods are passed an argument object, defined below. The only absolute
* requirement for ALL methods is .url. See individual methods for specifics.
*
* url :: {String} a resource url, and MKCOL name.
* targetUrl :: {String} target, when MOVEing or COPYing.
* asynch :: {Boolean} if true, an asynchronous call; defaults to false.
* callId :: {String} a unique id for this call. defaults to a random id.
* NOTE: The main purpose of this id is to prevent multiple identical
* xhr calls -- until a call with id[x] has returned, subsequent
* calls with id[x] will simply be ignored.
* callback :: {Function} a handler to receive the xhr result object.
* headers :: {Array} an assoc array of name/value pairs. [See XMLHTTP for defaults].
* propName :: {String} with .propPatch, propFind, name of property being accessed.
* propValue :: {String} with .propPatch, propFind, value of property being accessed.
* body :: {String} content body to be sent with request (PUT).
* acl :: {Array} acl to be set in this request (.setACL).
*/
/**
* @href http://greenbytes.de/tech/webdav/rfc4918.html#rfc.section.9.4
*/
this.HEAD = function(dav)
{
var d = dav || {};
d.method = 'HEAD';
return this.send(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc4918.html#rfc.section.9.4
*/
this.GET = function(dav)
{
var d = dav || {};
d.method = 'GET';
return this.send(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc4918.html#METHOD_POST
*/
this.POST = function(dav)
{
var d = dav || {};
d.method = 'POST';
return this.send(d);
};
/**
* NOTE: If no depth header is sent, header is set to depth:0
* @type {Mixed}
* @href http://greenbytes.de/tech/webdav/rfc4918.html#METHOD_PROPFIND
*/
this.PROPFIND = function(dav)
{
var d = dav || {};
d.method = 'PROPFIND';
/*
* Need to ensure that there is header information sent. Mainly,
* for a PROPFIND there must be a depth property.
*/
d.headers = d.headers || {};
d.headers['Depth'] = d.headers['Depth'] || 0;
return this.send(d);
};
/**
* Does a PROPPATCH on a resource.
* Takes an array of properties to set and remove
*
* @href http://greenbytes.de/tech/webdav/rfc4918.html#METHOD_PROPPATCH
* @see #setProperty
* @see #removeProperty
*
* @example:
* setProperties = [{
* name: "displayname",
* value: "foo.html"
* }, {
* ns: "http://www.limebits.com/ns/1.0"
* name: "Author",
* value: "Fitzgerald"
* }];
* AXIS.WebDAV.PROPPATCH({url: someURL, setProperties: setProperties});
*/
this.PROPPATCH = function(dav)
{
var d = dav || {};
d.method = 'PROPPATCH';
d.setProperties = dav.setProperties || [];
d.removeProperties = dav.removeProperties || [];
d.body = '\
';
var grouper = function(nm)
{
var props = d[nm + "Properties"];
var block = '';
for (var i = 0; i < props.length; i++)
{
var prop = props[i];
if (prop.name)
{
block += "" + prop.value + "";
}
}
block += '';
return block;
}
d.body += grouper("set");
d.body += grouper("remove");
d.body += '';
return this.send(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc3253.html#METHOD_REPORT
* @href http://greenbytes.de/tech/webdav/rfc3744.html#rfc.section.9.1
* @param {Object} dav An object containing options for this call.
*/
this.REPORT = function(dav)
{
var d = dav || {};
d.method = 'REPORT';
return this.send(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc4918.html#METHOD_MKCOL
* @param {Object} dav An object containing options for this call.
* @throws DAV_MKCOL_405
*/
this.MKCOL = function(dav)
{
var d = dav || {};
d.method = 'MKCOL';
AXIS.XMLHTTP.setStatusHandlerForResponse(d,
{
405: 'DAV_MKCOL_405'
});
return this.send(d);
};
/**
* Deletes a resource based on sent url.
*
* @param {Object} dav An object containing options for this call.
* @href http://greenbytes.de/tech/webdav/rfc4918.html#METHOD_DELETE
* @throws DAV_DELETE_404
*/
this.DELETE = function(dav)
{
var d = dav || {};
d.method = 'DELETE';
AXIS.XMLHTTP.setStatusHandlerForResponse(d,
{
404: 'DAV_DELETE_404'
});
return this.send(d);
};
/**
* Puts a file (writes the content of the sent .body to a url)
*
* @param {Object} dav An object containing options for this call.
* @throws DAV_PUT_NO_BODY
* @href http://greenbytes.de/tech/webdav/rfc4918.html#METHOD_PUT
*/
this.PUT = function(dav)
{
var d = dav || {};
d.method = 'PUT';
d.headers = dav.headers || {};
if(!d.headers['Content-Type'])
{
d.headers['Content-Type'] = 'text/html'
};
/**
* There must be a body for a PUT, but it is allowed to be
* empty (an empty string). Check for an undefined body.
*/
if(d.body === undefined)
{
AXIS.Errors.catchError(new Error('DAV_PUT_NO_BODY'));
return false;
}
return this.send(d);
};
/**
* Will copy a file. The call object expects you to send a .destination
* string (the new resource url). Optionally, you may send a .overwrite
* string (`T` || `F`), indicating what to do re: overwrites. This defaults
* to `F`. An optional smart copy feature choosing alternate names for you if
* the destination url is taken.
*
* @param {Object} dav An object containing options for this call.
* @throws DAV_COPY_403
* @throws DAV_COPY_404
* @throws DAV_COPY_409
* @throws DAV_COPY_412
* @href http://greenbytes.de/tech/webdav/rfc4918.html#METHOD_COPY
*/
this.COPY = function(dav)
{
var d = dav || {};
d.method = 'COPY';
d.origUrl = d.url;
if(d.destination === undefined)
{
AXIS.Errors.catchError(new Error('DAV_COPY_NO_DESTINATION'));
return false;
}
d.headers = {
Destination: d.destination,
Overwrite: d.overwrite ? 'T' : 'F'
};
AXIS.XMLHTTP.setStatusHandlerForResponse(d,
{
403: 'DAV_COPY_403',
404: 'DAV_COPY_404',
409: 'DAV_COPY_409',
412: !d.tryAlternateNames ? 'DAV_COPY_412' : function() {
/* Smart copy handler. Tries to find alternate unused name at destination */
if (d.overwrite) return 'DAV_COPY_412';
var dst_folder = AXIS.Util.uri.getFolder(d.destination);
var dst_name = AXIS.Util.uri.basename(d.destination);
AXIS.WebDAV.PROPFIND({
url: dst_folder,
headers: {
'Depth': '1'
},
callback: function(r) {
var responses = r.responseXMLObject().multistatus.response;
var children = [];
for (var i = 1; i < responses.length; i++)
{
children.push(AXIS.Util.uri.basename(responses[i].href));
}
var alternate_name = AXIS.Util.uri.findAlternateName(dst_name, children);
return AXIS.WebDAV.COPY({
url: d.origUrl,
destination: dst_folder + alternate_name,
alternateName: alternate_name,
callback: d.callback,
on201: d.on201
});
}
})
}
});
/**
* Need to do more stuff here, reading response for reason
*/
d.on207 - d.on207 || function()
{
// do something here.
}
return this.send(d);
};
/**
* Will move a file. The call object expects you to send a .destination
* string (the new resource url). Optionally, you may send a .overwrite
* string (`T` || `F`), indicating what to do re: overwrites. This defaults
* to `F`.
*
* @param {Object} dav An object containing options for this call.
* @throws DAV_MOVE_403
* @throws DAV_MOVE_404
* @throws DAV_MOVE_409
* @throws DAV_MOVE_412
* @href http://greenbytes.de/tech/webdav/rfc4918.html#METHOD_MOVE
*/
this.MOVE = function(dav)
{
var d = dav || {};
d.method = 'MOVE';
if(d.destination === undefined)
{
AXIS.Errors.catchError(new Error('DAV_MOVE_NO_DESTINATION'));
return false;
}
d.headers = {
Destination: d.destination,
Overwrite: d.overwrite ? 'T' : 'F',
Depth: d.depth || 0
};
AXIS.XMLHTTP.setStatusHandlerForResponse(d,
{
403: 'DAV_MOVE_403',
404: 'DAV_MOVE_404',
409: 'DAV_MOVE_409',
412: 'DAV_MOVE_412'
});
/**
* Need to do more stuff here, reading response for reason
*/
d.on207 - d.on207 || function()
{
// do something here.
}
return this.send(d);
};
this.VERSION_CONTROL = function(dav)
{
var d = dav || {};
d.method = "VERSION-CONTROL";
this.send(d);
};
this.CHECKOUT = function(dav)
{
var d = dav || {};
d.method = "CHECKOUT";
this.send(d);
};
this.CHECKIN = function(dav)
{
var d = dav || {};
d.method = "CHECKIN";
this.send(d);
};
/**
* Search ported from search.js
*
* @param {Object} dav An object containing options for this call.
*/
this.SEARCH = function(dav)
{
// utility
var _prop_to_xml = this.SEARCH._prop_to_xml;
// options
var d = dav || {};
d.props = dav.props || ["allprop"],
d.depth = dav.depth || 1,
d.where = dav.where || null,
d.limit = dav.limit || null,
d.offset = dav.offset || null,
d.orderby = dav.orderby || null
d.url = dav.url;
d.method = "SEARCH";
/*
xml builder functions
*/
// TODO this could probably be abstracted out a bit
var builder = {
_propXML: function() {
var props = d.props;
if (props[0] == 'allprop') {
return '';
} else {
var propXML = '';
for (var i=0; i < props.length; i++) {
propXML += _prop_to_xml(props[i]);
}
return '' + propXML + '';
}
},
_whereXML: function() {
var whereXML = '';
if(d.where) {
whereXML = '' + d.where + '';
}
return whereXML;
},
_orderbyXML: function() {
var orderbyXML = '';
if (d.orderby) {
orderbyXML += '';
orderbyXML += '' + _prop_to_xml(d.orderby) + '';
if (d.order) {
orderbyXML += '<' + d.order + '/>';
}
orderbyXML += '';
}
return orderbyXML;
},
_limitXML: function() {
var limitXML = '';
if(d.limit) {
limitXML = '' + d.limit + '';
}
return limitXML;
},
_offsetXML: function() {
var offsetXML = '';
if(d.offset) {
offsetXML = '' + d.offset + '';
}
return offsetXML;
}
}
d.body = dav.body || ' \
\
\
\
\
\
' + d.url + ' \
' + d.depth + ' \
\
\
' + builder._whereXML() + ' \
' + builder._orderbyXML() + ' \
' + builder._limitXML() + ' \
' + builder._offsetXML() + ' \
\
\
';
return this.send(d);
};
/**
* Locks a resource.
*
* @param {Object} dav An object containing options for this call.
* @href http://greenbytes.de/tech/webdav/rfc4918.html#METHOD_LOCK
* @throws DAV_LOCK_412
*/
this.LOCK = function(dav)
{
var d = dav || {};
d.url = d.url || false;
d.method = 'LOCK';
d.timeout = d.timeout || 'Second-' + this._defaultLOCKTimeout;
d.depth = d.depth || this.defaultLOCKDepth;
d.lockscope = d.lockscope || this._defaultLOCKScope;
d.locktype = d.locktype || this._defaultLOCKType;
/**
* If-Match will stop a lock from being taken on an unmapped
* url -- which would normally create an locked, empty, resource.
*/
d.headers = {
Timeout: d.timeout,
Depth: d.depth,
'If-Match': '*'
};
/**
* Create the block. If the user is logged in,
* this becomes '/home/usernamehere'; otherwise, it is unauthenticated.
*/
var user = AXIS.User.username();
var ublk = (user) ? '/home/' + user + '' : '';
d.owner = (user) ? '/home/' + user : 'unauthenticated';
d.body =
'\
\
\
\
\
\
\
\
' + ublk + '\
';
AXIS.XMLHTTP.setStatusHandlerForResponse(d,
{
200: function(r)
{
var lob = {};
/**
* We have to check if the lock is successful, and store lock
* tokens. 200 is a success. Now parse the data.
*/
var t = r.responseXMLObject().prop.lockdiscovery.activelock;
lob.depth = t.depth;
lob.owner = t.owner;
lob.timeout = t.timeout;
lob.token = t.locktoken.href;
for(var m in t.locktype)
{
lob.locktype = m;
}
for(var m in t.lockscope)
{
lob.lockscope = m;
}
AXIS.WebDAV.Locks.store(lob);
//alert('locktype:' + locktype + ' lockscope:' + lockscope + ' depth:' + depth + ' owner:' + owner + ' timeout:' + timeout + ' token:' + token);
},
412: 'DAV_LOCK_412~~' + d.url
/*
* 423's (locked) are handled automagically by AXIS.XMLHTTP
*/
});
return this.send(d);
};
/**
* Attempts to unlock a resource
*
* @param {Object} dav An object containing options for this call.
* @href http://greenbytes.de/tech/webdav/rfc4918.html#METHOD_UNLOCK
* @throws DAV_UNLOCK_400
* @throws DAV_UNLOCK_403
* @throws DAV_UNLOCK_409
*/
this.UNLOCK = function(dav)
{
var d = dav || {};
d.method = 'UNLOCK';
d.headers = {
//'Lock-Token': ''
};
AXIS.XMLHTTP.setStatusHandlerForResponse(d,
{
400: 'DAV_UNLOCK_400~~' + d.url,
403: 'DAV_UNLOCK_403~~' + d.url,
409: 'DAV_UNLOCK_409~~' + d.url
});
return this.send(d);
};
/**
* Helper methods.
* Functionality that prepares particular flavours of DAV
* calls. The requirement of all of these methods is that
* they ultimately return the response from a standard
* DAV method, as defined above.
*/
/**
* Retrieves a range of bytes from a resource.
*
* @see http://www.faqs.org/rfcs/rfc2616.html
*/
this.getByteRange = function(dav)
{
var d = dav || {};
d.method = 'GET';
/**
* Must have a byte range...
*/
if(!d.byteRange)
{
AXIS.Errors.catchError(new Error('DAV_NO_RANGE'));
}
d.headers = d.headers || {};
d.headers['Range'] = 'bytes=' + d.byteRange;
/**
* A 206 response (partial content) is what you expect;
* A 416 response (requested range not satisfiable) is of course an error.
*/
d.failureCodes = [416];
return this.send(d);
};
/**
* Gets a property on a resource. Expects a property name. You may also
* send an array of properties to fetch.
*
* NOTE: This method, whether the prop is found or not, returns the status
* code of 207.
*
* @param {Object} dav An object containing options for this call.
* @see #PROPFIND
*/
this.xgetProperty = function(dav)
{
var d = dav || {};
d.property = dav.property || '';
d.body = ' \
\
';
var isArr = (d.property.constructor === Array);
if(isArr)
{
for(var x=0; x < d.property.length; x++)
{
d.body += '';
}
}
else
{
d.body += '';
}
d.body += '';
/**
* Usually we leave result handling to the implementor, but here we create
* a little quick access to result node, ._result, so the implementor
* doesn't have to worry about setting a 207, etc. (NOTE: that if an on207
* is set, we still will call it...)
*/
d._result = [];
var o2 = d.on207 || AXIS.F;
AXIS.XMLHTTP.setStatusHandlerForResponse(d,
{
207: function(r)
{
try
{
var rr = r.responseXMLObject().multistatus.response.propstat.prop;
if(isArr)
{
var dd = d.property;
for(var z=0; z < dd.length; z++)
{
r._result[dd[z]] = rr[dd[z]];
}
}
else
{
r._result[r.property] = rr[r.property];
}
}
catch(e){}
o2(r);
}
});
return this.PROPFIND(d);
};
/**
* Sets a property on a resource. Expects a property name. You may also
* send an array of properties to set.
*
* NOTE: This is essentially an alias to the PROPPATCH method, and expects the
* arguments defined for that method for *setting* values. The one thing it
* does add is the ability to send a single (not array) setValues value, which
* is promptly converted into an array and sent along.
*
* @param {Object} dav An object containing options for this call.
* @see #PROPPATCH
* @throws DAV_BAD_PROPSET_ARGS
*/
this.setProperty = function(dav)
{
var d = dav || {};
if(d.setValues && d.setProperty)
{
d.setValues = (d.setValues.constructor === Array) ? d.setValues : [d.setValues];
}
else
{
AXIS.Errors.catchError(new Error('DAV_BAD_PROPSET_ARGS'));
}
return this.PROPPATCH(d);
};
/**
* Removes a property on a resource. Expects a property name. You may also
* send an array of properties to remove.
*
* NOTE: This is essentially an alias to the PROPPATCH method, and expects the
* arguments defined for that method for *removing* values. The one thing it
* does add is the ability to send a single (not array) removeValues value, which
* is promptly converted into an array and sent along.
*
* @param {Object} dav An object containing options for this call.
* @see #PROPPATCH
* @throws DAV_BAD_PROPREMOVE_ARGS
*/
this.removeProperty = function(dav)
{
var d = dav || {};
if(d.removeValues && d.removeProperty)
{
d.removeValues = (d.removeValues.constructor === Array) ? d.removeValues : [d.removeValues];
}
else
{
AXIS.Errors.catchError(new Error('DAV_BAD_PROPREMOVE_ARGS'));
}
return this.PROPPATCH(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc3253.html#REPORT_version-tree
*
* @param {Object} dav An object containing options for this call.
* @see #REPORT
* @return The response from #REPORT
* @type Object
*/
this.getVersionTreeReport = function(dav)
{
var d = dav || {};
d.body = '\
\
\
\
\
\
\
\
';
d.headers = {
'Depth': 0
};
return this.REPORT(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc3253.html#REPORT_expand-property
*
* @param {Object} dav An object containing options for this call.
* @see #REPORT
* @return The response from #REPORT
* @type Object
*/
this.getExpandPropertyReport = function(dav)
{
var d = dav || {};
d.body = '\
\
\
\
\
\
\
\
';
return this.REPORT(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc3744.html#REPORT_acl-principal-prop-set
*
* @param {Object} dav An object containing options for this call.
* @see #REPORT
* @return The response from #REPORT
* @type Object
*/
this.getAclPrincipalPropSetReport = function(dav)
{
var d = dav || {};
d.body = '\
\
\
\
\
';
d.headers = {
'Depth': 0
};
return this.REPORT(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc3744.html#REPORT_principal-match
*
* @param {Object} dav An object containing options for this call.
* @see #REPORT
* @return The response from #REPORT
* @type Object
*/
this.getPrincipalMatchReport = function(dav)
{
var d = dav || {};
d.body = '\
\
\
\
\
';
d.headers = {
'Depth': 0
};
return this.REPORT(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc3744.html#REPORT_principal-property-search
*
* @param {Object} dav An object containing options for this call.
* @see #REPORT
* @return The response from #REPORT
* @type Object
*/
/*
this.getPrincipalPropertySearchReport = function(dav)
{
var d = dav || {};
d.body = '';
d.headers = {
'Depth': 0
};
return this.REPORT(d);
};
*/
/**
* @href http://greenbytes.de/tech/webdav/rfc3744.html#REPORT_principal-search-property-set
*
* @param {Object} dav An object containing options for this call.
* @see #REPORT
* @return The response from #REPORT
* @type Object
*/
this.getPrincipalSearchPropertySetReport = function(dav)
{
var d = dav || {};
d.body = '\
';
d.headers = {
'Depth': 0
};
return this.REPORT(d);
};
/**
* Gets all properties on a resource. A resouce can either be a single "file",
* or a collection resource (folder). For a collection, this would fetch you
* a collection ("directory") listing, with each "sub" resource described in the
* same way it would have been had its properties been requested via this method.
*
* Because this dual nature of resources may be strange or ambiguous to some,
* and due to the very real possibility that the resource type of the url passed
* to this call is not known in advance, we add a useful object with semi-parsed
* data to the return object, so that the developer can easily determine the
* type of resource returned, as well as all bound resources in the case
* of collections.
*
* @param {Object} dav An object containing options for this call.
* @see #PROPFIND
* @return The response from #PROPFIND
* @type Object
*/
this.getResourceProps = function(dav)
{
var d = dav || {};
d.body = '\
\
\
';
d.headers = {
'Depth': 1
};
/**
* Ensure that our new properties are set in the return object by
* creating this proxy callback which passes on the info.
*/
var c2 = d.callback || AXIS.F;
d.callback = function(r)
{
/**
* Prepare a response object so that the developer
* doesn't have to bother with parsing -- we can expect
* that this function was called to get a collection record,
* and so this parsing will be useful.
*/
r._result =
{
type: 'failed',
href: '',
resources: []
};
/**
* It's likely that we'll get non-responses back. That's fine,
* just don't want the code to cause errors, so try...catch.
*/
try
{
var st = r.responseXMLObject().multistatus.response;
var mult = (st.constructor === Array);
var res = mult ? st : [st];
var rt = res[0].propstat.prop.resourcetype;
/**
* Determine if we've just fetched a collection or not by reading
* the `resourcetype` of the first `resource` returned, ex.:
*
*
*
* /
*
*
*
*
*
* ...
*
* If it's NOT a collection, set .type to 'resource' and pass the
* single element array, resRoot; if a collection, set .type to 'collection'.
* We also pass along the .href of the first result, which will describe
* the url the PROPFIND executed on.
*/
r._result.type = (rt && rt.hasOwnProperty('collection')) ? 'collection' : 'resource';
r._result.href = res[0].href;
/**
* Build the result list, pushing the resource object's propstat.prop(s)
*/
for(var x=0; x < res.length; x++)
{
r._result.resources.push(res[x].propstat.prop);
}
}
catch(e){};
c2(r);
}
return this.PROPFIND(d);
};
/**
* Alias of {@link #getReourceProps}
*
* @param {Object} dav An object containing options for this call.
*/
this.readFolder = function(dav)
{
return this.getResourceProps(dav);
};
AXIS.Errors.register('DAV_ACE_CONFLICT', "An ace conflict occured", 2);
AXIS.Errors.register('DAV_ACE_INVALID_PRIVILEGES', "Privileges argument is invalid.", 3);
AXIS.Errors.register('DAV_ACL_CANNOT_REMOVE_INHERITED_ACE', "Inherted aces can only be removed on the ancestor.", 2);
AXIS.Errors.register('DAV_ACL_CANNOT_REMOVE_PROTECTED_ACE', "Protected aces cannot be removed.", 2);
AXIS.Errors.register('DAV_ACL_CORRUPTED', "The acl has been corrupted. Have you been editing it directly? ", 3);
AXIS.Errors.register('DAV_ACL_CHANGED', "The resource's acl has changed since you last fetched it. Try again and use a lock if possible.", 3);
var Acl = function(aceElements)
{
if (AXIS.isIE)
{
var acl = [];
AXIS.Util.lang.augmentObject(acl, this);
acl.parseAceElements(aceElements);
acl.indexOf = function(e, i)
{
i = i || 0;
if (i < 0)
{
i = this.length + (i % this.length);
}
for (; i < this.length; i++)
{
if (this[i] === e)
{
return i;
}
}
return -1;
}
return acl;
}
this.parseAceElements(aceElements);
}
Acl.prototype = new Array;
AXIS.Util.lang.augmentObject(Acl,
{
printPrincipal: function(prin,p)
{
var pretty = p || false;
var p_str = pretty ? '' : '';
var t;
switch(prin[0])
{
case AXIS.WebDAV.PRINCIPAL_ALL:
p_str += pretty ? 'All' : '';
break;
case AXIS.WebDAV.PRINCIPAL_AUTHENTICATED:
p_str += pretty ? 'Authenticated' : '';
break;
case AXIS.WebDAV.PRINCIPAL_UNAUTHENTICATED:
p_str += pretty ? 'UnAuthenticated' : '';
break;
case AXIS.WebDAV.PRINCIPAL_SELF:
p_str += pretty ? 'Self' : '';
break;
case AXIS.WebDAV.PRINCIPAL_PROPERTY:
if(prin[1][1] == "DAV:")
{
t = "";
}
else
{
t = "<" + prin[1][0] + " xmlns='" + prin[1][1] + "'/>";
}
if(pretty)
{
p_str += t;
}
else
{
p_str += '' + t + '';
}
break;
case AXIS.WebDAV.PRINCIPAL_USER:
t = AXIS._siteData.hosts.limebits + "users/" + prin[1];
if(pretty)
{
p_str += t;
}
else
{
p_str += '' + t + '';
}
break;
case AXIS.WebDAV.PRINCIPAL_GROUP:
t = AXIS._siteData.hosts.limebits + "groups/" + prin[1];
if(pretty)
{
p_str += t;
}
else
{
p_str += '' + t + '';
}
break;
case AXIS.WebDAV.PRINCIPAL_HREF:
p_str += pretty ? prin[1] : '' + prin[1] + '';
break;
}
p_str += "";
return p_str;
},
printPrivileges: function(privs)
{
var p_str = "";
for (var i = 0; i < privs.length; i++)
{
var priv = privs[i];
p_str += "";
if (priv[0] == "DAV:")
p_str += "";
else
p_str += "<" + priv[1] + " xmlns='" + priv[0] + "'/>";
p_str += "";
}
return p_str;
},
/**
* Get an array of privilge strings from the corresponding XML elements
*
* @param {Array} an array of D:privilege XML elements
*/
getPrivilegesFromElements: function(elems)
{
var privs = [];
for (var i = 0; i < elems.length; i++)
{
var j;
for (j = 0; j < elems[i].childNodes.length && elems[i].childNodes[j].nodeType != AXIS.ELEMENT_NODE; j++);
var priv = elems[i].childNodes[j].nodeName;
priv = priv.split(":").pop();
var priv_ns = elems[i].childNodes[j].namespaceURI;
privs.push([priv_ns, priv]);
}
return privs;
}
});
AXIS.Util.lang.augmentObject(Acl.prototype,
{
parseAceElements: function(aces_el) {
this.protectedAces = [];
this.editableAces = [];
this.inheritedAces = [];
for (var i = 0; i < aces_el.length; i++)
{
var ace_el = aces_el[i];
var principal = this.getPrincipalFromElem(AXIS.Util.xml.getChildrenByNameNS(ace_el, "principal")[0]);
var grant;
var inherited = false;
var isProtected = false;
if (AXIS.Util.xml.getChildrenByNameNS(ace_el, "protected").length)
isProtected = true;
var inherited = AXIS.Util.xml.getChildrenByNameNS(ace_el, "inherited")[0];
inherited = inherited ? AXIS.Util.xml.getText(AXIS.Util.xml.getChildrenByNameNS(inherited, "href")[0]) : false;
grant = AXIS.Util.xml.getChildrenByNameNS(ace_el, "grant").length ? true : false;
var privs = Acl.getPrivilegesFromElements(AXIS.Util.xml.getChildrenByNameNS(ace_el, "privilege"));
var ace = this.makeAce(grant, privs, principal, isProtected, inherited);
if (isProtected)
this.protectedAces.push(ace);
else if (inherited)
this.inheritedAces.push(ace);
else
this.editableAces.push(ace);
}
for (var i = 0; i < this.protectedAces.length; i++)
this.push(this.protectedAces[i]);
for (var i = 0; i < this.editableAces.length; i++)
this.push(this.editableAces[i]);
for (var i = 0; i < this.inheritedAces.length; i++)
this.push(this.inheritedAces[i]);
this._origACL = this.printXML();
},
/**
* Gets an internal representation of the principal element in XML.
*
* @param {Object} el A principal element in an xml doc.
* @return An internal represention of the element using an array.
* @href http://greenbytes.de/tech/webdav/rfc3744.html#ace.principal
*/
getPrincipalFromElem: function(el)
{
var principal = null;
var href = AXIS.Util.xml.getChildrenByNameNS(el, "href", "DAV:");
if (href.length > 0)
{
href = AXIS.Util.xml.getText(href[0]);
if (href.indexOf(AXIS._siteData.hosts.limebits + "users/") == 0)
principal = [AXIS.WebDAV.PRINCIPAL_USER, AXIS.Util.uri.basename(href)];
else if (href.indexOf(AXIS._siteData.hosts.limebits + "groups/") == 0)
principal = [AXIS.WebDAV.PRINCIPAL_GROUP, AXIS.Util.uri.basename(href)];
else
principal = [AXIS.WebDAV.PRINCIPAL_HREF, href];
return principal;
}
if (AXIS.Util.xml.getChildrenByNameNS(el, "all").length == 1)
principal = [AXIS.WebDAV.PRINCIPAL_ALL];
else if (AXIS.Util.xml.getChildrenByNameNS(el,"authenticated").length == 1)
principal = [AXIS.WebDAV.PRINCIPAL_AUTHENTICATED];
else if (AXIS.Util.xml.getChildrenByNameNS(el, "unauthenticated").length == 1)
principal = [AXIS.WebDAV.PRINCIPAL_UNAUTHENTICATED];
else if (AXIS.Util.xml.getChildrenByNameNS(el, "self").length == 1)
principal = [AXIS.WebDAV.PRINCIPAL_SELF];
else
{
var prop_el = AXIS.Util.xml.getChildrenByNameNS(el, "property")[0];
if (prop_el)
{
var j;
for (j = 0; j < prop_el.childNodes.length && prop_el.childNodes[j].nodeType != AXIS.ELEMENT_NODE; j++);
prop_el = prop_el.childNodes[j];
principal = [AXIS.WebDAV.PRINCIPAL_PROPERTY, [prop_el.nodeName.split(":").pop(), prop_el.namespaceURI]];
}
}
return principal;
},
/**
* Creates an internal representation of an ace
*
* @param {Boolean} grant If true, creates a grant ace. If false, creates a deny ace.
* @param {Array/String} privs An array of privileges to be managed by this ace. Each privilege is itself an array of the form ["namespace", "privilege"]. For convenience, if the namespace is "DAV:", the privilege can be represented by the string "privilege". If providing exactly one privilege, and it is in the "DAV:" namespace, this parameter can be the string "privilege". Egs: [["http://limebits.com/ns/1.0/", "read-private-properties"]]; [["DAV:", "read"], "write-content"]; "write-content";
* @param {Acl.prin_t} principal Principals affected by this ace
* @param {Boolean} isProtected (optional) If true, create an ace marked as protected. Defaults to false
* @param {String} inherited (optional) A string containing the href of the resource this ace is inherited. Defaults to creating an uninherited ace.
* @return {Object} An object representing the ace
* @href http://greenbytes.de/tech/webdav/rfc3744.html#PROPERTY_acl
*/
makeAce: function(grant, privs, principal, isProtected, inherited)
{
isProtected = isProtected ? true : false;
inherited = inherited ? inherited : false;
if (privs instanceof Array)
{
for (var i = 0; i < privs.length; i++)
{
var priv = privs[i];
if (!(priv instanceof Array))
privs[i] = ["DAV:", priv];
}
}
else if (typeof privs === 'string')
privs = [["DAV:", privs]];
else
throw new Error('DAV_ACE_INVALID_PRIVILEGES');
privs.hasPriv = function(priv, priv_ns)
{
if (priv_ns == null)
priv_ns = "DAV:";
for (var i = 0; i < privs.length; i++)
{
var p = privs[i];
if (priv_ns == p[0] && priv == p[1] )
return true;
}
return false;
}
if (!(principal instanceof Array))
principal = [principal];
return {
principal: principal,
isProtected: isProtected,
inherited: inherited,
grant: grant,
privs: privs
};
},
findAces: function(grant, privs, principal)
{
var ace = this.makeAce(grant, privs, principal);
var matchingAces = [];
for (var i = 0; i < this.length; i++)
{
if (this[i].grant == ace.grant)
{
if (Acl.printPrincipal(this[i].principal) == Acl.printPrincipal(ace.principal))
{
for (var j = 0; j < ace.privs.length; j++)
if (this[i].privs.hasPriv(ace.privs[j][1], ace.privs[j][0]))
matchingAces.push(this[i]);
}
}
}
return matchingAces;
},
/**
* Checks if a provided ace conflicts with any of the existing protected or editable aces
*
* @param {Object} ace Object containing the details of the ace that needs to be added
* @throws DAV_ACE_CONFLICT
* @href http://greenbytes.de/tech/webdav/rfc3744.html#rfc.section.8.1.3
*/
checkAceConflict: function(ace)
{
for (var i = 0; i < this.length; i++)
{
if (this[i].inherited && !this[i].isProtected)
continue;
if (this[i].grant ? !ace.grant : ace.grant)
{
if (Acl.printPrincipal(this[i].principal) == Acl.printPrincipal(ace.principal))
{
for (var j = 0; j < ace.privs.length; j++)
if (this[i].privs.hasPriv(ace.privs[j][1], ace.privs[j][0]))
throw new Error('DAV_ACE_CONFLICT~~' + "Ace " + this.printACE(ace)+ " conflicts with" + (this[i].isProtected ? " protected" : "") + " ace " + this.printACE(this[i]));
}
}
}
},
/**
* Checks if a provided ace conflicts with any of the existing protected or editable aces
*
* @param {Boolean} grant If true, adds a grant ace. If false, adds a deny ace.
* @param {Array/String} privs see @param privs of makeAce
* @param {Acl.prin_t} principal see @param principal of makeAces
* @param {Integer} index (optional) The position in the acl at which to add the ace. The index must be within the editable aces
* @return {Integer} The position at which the ace was actually added
* @throws DAV_ACE_CONFLICT
* @href http://greenbytes.de/tech/webdav/rfc3744.html#rfc.section.8.1.3
*/
addAce: function(grant, privs, principal, index)
{
var ace = this.makeAce(grant, privs, principal);
this.checkAceConflict(ace);
if (index == null || index < this.protectedAces.length) /* Insert at the head of the editable aces */
index = this.protectedAces.length;
else if (index > this.protectedAces.length + this.editableAces.length) /* Insert at the tail of the editable aces */
index = this.protectedAces.length + this.editableAces.length;
this.editableAces.splice(index - this.protectedAces.length, 0, ace);
this.splice(index, 0, ace);
return index;
},
/**
* Removes the editable ace at a given index
*
* @param {Integer} index The index of the ace which is to be removed
* @throws DAV_ACL_CANNOT_REMOVE_PROTECTED_ACE
* @throws DAV_ACL_CANNOT_REMOVE_INHERITED_ACE
* @throws DAV_ACL_CORRUPTED
*/
removeAce: function(index)
{
if (this[index].isProtected)
throw new Error('DAV_ACL_CANNOT_REMOVE_PROTECTED_ACE');
if (this[index].inherited)
throw new Error('DAV_ACL_CANNOT_REMOVE_INHERITED_ACE');
var edIndex = index - this.protectedAces.length;
if (this[index] != this.editableAces[edIndex])
throw new Error('DAV_ACL_CORRUPTED');
this.editableAces.splice(edIndex, 1)
return this.splice(index, 1)[0];
},
/**
* Removes all the editable aces in this acl
*
* @throws DAV_ACL_CORRUPTED
*/
clearEditableAces: function()
{
this.splice(this.protectedAces.length, this.editableAces.length);
this.editableAces = [];
if (this.length != this.protectedAces.length + this.inheritedAces.length)
throw new Error('DAV_ACL_CORRUPTED');
},
printACE: function(ace)
{
var aceXML = "";
aceXML += "";
aceXML += Acl.printPrincipal(ace.principal);
aceXML += "";
aceXML += Acl.printPrivileges(ace.privs);
aceXML += "";
if (ace.isProtected)
aceXML += "";
else if (ace.inherited)
aceXML += "" + ace.inherited + "";
aceXML += "";
return aceXML;
},
/**
* Print the aces of the acl
*
* @param {Boolean} editableOnly (optional) If true, outputs only the editable aces.
* @return {String} The acl property as a string
*/
printXML: function(editableOnly)
{
var aclArray = editableOnly ? this.editableAces : this;
var aclXML = '';
for (var i = 0; i < aclArray.length; i++)
aclXML += this.printACE(aclArray[i]);
aclXML += "";
return aclXML;
}
});
this.Acl = Acl;
/**
* Gets the Current User Privilege Set for a resource.
*
* @param {Object} dav An object containing options for this call.
* @href http://greenbytes.de/tech/webdav/rfc3744.html#PROPERTY_current-user-privilege-set
*/
this.getCUPS = function(dav)
{
var d = dav || {}
d.body = '\
\
\
\
\
';
/**
* On a successful response, we create a simple accessor for CUPS, extending
* the response with an .allows method, letting the developer now check
* directly if a user has a given priviledge by checking value of
* response.allows('write'), for example.
*/
d.responseProcessor = function(r)
{
var ps = AXIS.Util.xml.getChildrenByNameNS(r.responseXML.documentElement, "propstat", "DAV:")[0];
var st = AXIS.Util.xml.getChildrenByNameNS(ps, "status", "DAV:")[0].firstChild.nodeValue;
if (st.indexOf("200 OK") < 0)
return null;
var privs = Acl.getPrivilegesFromElements(AXIS.Util.xml.getChildrenByNameNS(ps, "privilege"));
privs.hasPriv = function(priv, priv_ns)
{
if (priv_ns == null)
priv_ns = "DAV:";
for (var i = 0; i < privs.length; i++)
{
var p = privs[i];
if (priv_ns == p[0] && priv == p[1] )
return true;
}
return false;
}
r.privs = privs;
r.allows = privs.hasPriv; // backward compatibility
return privs;
};
return this.PROPFIND(d);
};
/**
* Gets the ACL for a resource.
*
* @param {Object} dav An object containing options for this call.
* @href http://greenbytes.de/tech/webdav/rfc3744.html#rfc.section.5.5.5
*/
this.getACL = function(dav)
{
var d = dav || {};
d.body = '\
\
\
\
\
';
/**
* On a successful response, we create an array of ACE's, to facilitate
* access for the developer. Could probably do more here.
*/
d.responseProcessor = function(r)
{
var ps = AXIS.Util.xml.getChildrenByNameNS(r.responseXML.documentElement, "propstat")[0];
var st = AXIS.Util.xml.getChildrenByNameNS(ps, "status")[0].firstChild.nodeValue;
/* FIXME: handle this error better */
if (st.indexOf("200 OK") < 0)
return null;
var acl = new AXIS.WebDAV.Acl(AXIS.Util.xml.getChildrenByNameNS(ps, "ace"));
r.aces = acl;
return acl;
}
return this.PROPFIND(d);
};
/**
* Attempts to set the ACL on a resource
*
* @param {Object} dav An object containing options for this call.
* @href http://greenbytes.de/tech/webdav/rfc3744.html#METHOD_ACL
* @throws DAV_ACL_CHANGED
*/
this.setACL = function(dav)
{
var d = dav || {};
d.method = 'ACL';
return this.getACL(
{
url: d.url,
asynch: d.asynch,
callback: function(r, newAcl)
{
if (newAcl.printXML() != d.acl._origACL)
throw new Error("DAV_ACL_CHANGED");
var acl = d.acl.printXML(true);
d.body = '' + acl;
return AXIS.WebDAV.send(d);
}
});
};
this.getProperty = function(dav)
{
var d = dav || {};
var props = d.properties;
var xml = "";
for (var i=0; i < props.length; i++)
{
var prop = props[i];
if (prop.constructor !== Array)
{
prop = [prop];
}
if (prop.length == 1)
{
prop.unshift(d.ns || "DAV:"); // namespace
}
xml += "";
}
d.body = '\
\
\
' + xml + '\
\
';
return this.PROPFIND(d)
};
/**
* @href http://greenbytes.de/tech/webdav/rfc4918.html#rfc.section.9.1.4
*
* @param {Object} dav Contains the arguments necessary for call. At least .url.
* @see #PROPFIND
* @return The response from #PROPFIND
* @type Object
*/
this.getPropertyNames = function(dav)
{
var d = dav || {};
d.body = '\
\
\
';
return this.PROPFIND(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc4918.html#rfc.section.9.1.5
*
* @param {Object} dav Contains the arguments necessary for call. At least .url.
* @see #PROPFIND
* @return The response from #PROPFIND
* @type Object
*/
this.getAllProperties = function(dav)
{
var d = dav || {};
d.body = '\
\
\
';
return this.PROPFIND(d);
};
/**
* @href http://greenbytes.de/tech/webdav/rfc4918.html#rfc.section.9.1.6
*
* @param {Object} dav Contains the arguments necessary for call. At least .url.
* @see #PROPFIND
* @return The response from #PROPFIND
* @type Object
*/
this.getAllIncludedProperties = function(dav)
{
var d = dav || {};
d.body = '\
\
\
\
\
\
\
';
return this.PROPFIND(d);
};
this.mkcolParents = function(dav)
{
var self = this;
var d = dav || {};
var parentUrl = d.url.replace(/\/[^\/]*\/?$/, '/');
var d2 = AXIS.merge(dav, {
on409: function() {
self.mkcolParents({
url: parentUrl,
onSuccess: function() {
self.MKCOL(d);
}
});
}
});
self.MKCOL(d2);
}
/**
* Does checks on send arguments, prepares a proper
* call object, and returns it. NOTE that since this object is a DAV-specific
* preparation of an XHR call, and will ultimately be sent as an XHR call,
* the object is further (more strongly) validated within Loader.load().
*
* @private
* @param {Object} dav This is passed through by each DAV method, and
* is the original arg object sent by user
* @return A properly prepared call.
* @type Object
*/
this._prepare = function(dav)
{
dav.asynch = (dav.asynch === undefined) ? false : !!dav.asynch;
dav.loadingMsg = dav.loadingMsg || 'DAV::' + dav.method + '::' + dav.url;
/**
* Make sure sent object has .headers set; if not, empty object.
*/
dav.headers = dav.headers || {};
for(var p in this.defaultHeaders)
{
dav.headers[p] = dav.headers[p] || this.defaultHeaders[p];
}
/*
* Gives the returned object the ability to fetch the
* response in object form (allowing for easy iteration)
*/
dav.responseXMLObject = this._responseXMLObject;
/**
* Do some pruning of empty space if we can.
*/
dav.body && dav.body.replace(/(\>\s*\<)/g, "><");
return dav;
};
/**
* Makes the Loader call, passing the DAV call object.
*
* @param {Object} dav A WebDAV call object.
* @return Reference to call object in AXIS.Queue if successful; false if not
* @type Object
*/
this.send = function(dav)
{
var p = this._prepare(dav || {});
if(p)
{
return AXIS.Loader.load(p);
}
return false;
};
/**
* Function attached as a public method of an XML response.
* Freely distributable under the terms of an MIT-style license.
*
* @private
* @see #prepare.
* @author Shinichi Tomita
*/
this._responseXMLObject = function()
{
if(this.httpHandle && this.httpHandle.responseXML)
{
var o = dom2obj(this.httpHandle.responseXML.documentElement);
var obj = {};
obj[o.tag] = o.value;
return obj;
}
else
{
return false;
}
function dom2obj(elem)
{
if(elem.nodeType == AXIS.TEXT_NODE)
{
return elem.data;
}
else if(elem.nodeType == AXIS.ELEMENT_NODE)
{
var obj = {};
var hasprops = false;
for(var i=0; i.
*/
/**
* @fileoverview
*
* @requires AXIS
* @requires WebDAV
* @requires Cookies
* @requires User
*/
function Login()
{
/**
* @constructor
*/
this.__construct = function()
{
this.forceLogin = false;
this.redirReturnTo = window.location.href;
this.authCookie = false;
this._authState = null;
this._loginFrameWindow = {};
this._returnTo = location.protocol + "//" + location.host + "/!lime/root/logout";
this._baseHomePath = "http://limebits.com/apps/finder/#folder=/home/";
AXIS.Errors.register('LB_LOGOUT_INVALID_SIGNOUT', "Couldn't log out of all domains", 3);
this.onAuthUpdate = AXIS.CustomEvents.create();
this.beforeLogout = AXIS.CustomEvents.create();
/*
* Fetch site/user login data and store. Note that this is
* synchronous.
*/
var resp = AXIS.WebDAV.GET({
method: 'GET',
url: '/!lime/root/lib/site.json',
asynch: false,
callId: 'LOGIN_FETCH_DATA'
});
AXIS._siteData = eval('('+resp.responseText+')');
if(AXIS.settings('noLogin') === false)
{
AXIS.onContentReady(function() {
this._createAutoLoginFrame();
this.login();
},this);
}
};
this._authStateUpdate = function(state)
{
if (state === this._authState)
return;
this._authState = state;
this.onAuthUpdate.fire([state]);
}
/*
* The login/auth check, executed on every page
*/
this.login = function()
{ //alert('logging in');
/*
* This is a non-cached resource. Ensures that we have the latest cookies.
*/
AXIS.WebDAV.GET({
method: 'GET',
url: '/!lime/root/logout',
asynch: false,
callId: 'LOGIN_CHECK'
});
if(AXIS.Cookies.read('auth') && !AXIS.Cookies.read('user'))
{
AXIS.Cookies.erase('auth');
}
// return if already logged in
if(AXIS.User.isLoggedIn())
{
return this._authStateUpdate(AXIS.Cookies.read('user'));
}
AXIS.Login.setAuthCookie(
function()
{
AXIS.Login._submitAutoLoginFrame();
});
return true;
};
this.logout = function()
{
AXIS.Login.beforeLogout.fire({
args: []
});
if (location.protocol + "//" + location.host + "/" == AXIS._siteData.hosts.limebits)
{
AXIS.Login._submitAutoLogoutFrame();
}
else
{
AXIS.Cookies.erase('auth');
AXIS.Cookies.erase('user');
this._authStateUpdate(false);
}
};
this.setAuthCookie = function(cb)
{
this.authCookie = AXIS.Cookies.read('auth');
if(!this.authCookie)
{
AXIS.WebDAV.GET(
{
method: 'GET',
url: '/!lime/root/authonly',
on401: function(r)
{
AXIS.Login.authCookie = AXIS.Cookies.read('auth');
//alert(r.responseText);
},
callback: function(r)
{
AXIS.Login.authCookie = AXIS.Cookies.read('auth');
cb();
},
asynch: false,
callId: 'GET_AUTH_COOKIE'
}
);
}
};
/**
* Creates the autologin frame in DOM
*
* @see #_loadFrameHandler
*/
this._createAutoLoginFrame = function()
{
var loginFrame = document.createElement('iframe');
loginFrame.style.display = 'none';
var frm = document.body.appendChild(loginFrame);
if (frm.contentDocument && frm.contentDocument.defaultView)
this._loginFrameWindow = frm.contentDocument.defaultView;
else
this._loginFrameWindow = frm.contentWindow;
this._loginFrameEl = frm;
AXIS.attachEvent('load',this._loadFrameHandler,frm);
};
/**
* When the login frame (referenced by #_loginFrameWindow; @see #_createAutoLoginFrame)
* has its src changed, this is the handler fired when given src is loaded.
*
* @private
* @see #_createAutoLoginFrame
*/
this._loadFrameHandler = function()
{
var loc = AXIS.Login._loginFrameWindow.location;
var hsh;
try
{
hsh = loc.hash;
if (hsh === undefined || loc.pathname != '/!lime/root/logout')
throw "error";
} catch(e) { return; }
hsh = hsh.split('#')[1] || false;
//alert('loc: ' + loc + ' - ' + 'hash: ' + hsh);
var cook = AXIS.Cookies.read('user');
switch(hsh)
{
case false:
if (cook)
{
AXIS.Login._authStateUpdate(cook);
break;
}
case 'noauth':
case 'noallow':
// TODO: look into handling no_allow with a modal iframe popup
if(AXIS.Login.forceLogin)
{
AXIS.Login._redirectToAccess();
}
else
{
AXIS.Login._authStateUpdate(false);
}
break;
case "signout":
AXIS.Cookies.erase('auth');
AXIS.Cookies.erase('user');
AXIS.Login._authStateUpdate(false);
break;
case "nosignout":
throw new Error('LB_LOGOUT_INVALID_SIGNOUT');
break;
default:
break;
}
};
/**
* Submits the login frame created with #_createAutoLoginFrame
*
* @see #_loadFrameHandler
*/
this._submitAutoLoginFrame = function()
{
//alert('submitting frame');
AXIS.Login._loginFrameWindow.location.replace(AXIS._siteData.hosts.secure + 'secure/auth_validator.html#auth_cookie=' + AXIS.Login.authCookie + '&return_to=' + escape(AXIS.Login._returnTo));
};
this._redirectToAccess = function(join)
{
AXIS.Login.authCookie = AXIS.Cookies.read('auth');
top.location = AXIS._siteData.hosts.secure + 'secure/access.html#auth_cookie=' + AXIS.Login.authCookie + (join ? ('&sign_up=' + join) : '') + (AXIS.Login.redirReturnTo ? ('&return_to=' + escape(AXIS.Login.redirReturnTo)) : '');
}
this._submitAutoLogoutFrame = function()
{
AXIS.Login.authCookie = AXIS.Cookies.read('auth');
AXIS.Login._loginFrameWindow.location.replace(AXIS._siteData.hosts.secure + 'secure/auth_validator.html#logout=1&www_auth_cookie=' + AXIS.Login.authCookie + '&return_to=' + escape(AXIS.Login._returnTo));
}
/*
* @return {String} full path to user home folder
*/
this.homePath = function()
{
return this._baseHomePath + AXIS.User.isLoggedIn();
};
};
/**
* Copyright 2008, 2009 Lime Labs LLC
*
* This file is part of AXIS.
*
* AXIS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License
* version 3 as published by the Free Software Foundation.
*
* AXIS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with AXIS. If not, see .
*/
/**
* @fileoverview
*
* AXIS is the core framework that all other objects register with. It is
* inherited as the prototype of any class attached via its #register method.
* This is an essential library, and nothing will work without it. It is
* expected that the core of your build will be the AXIS supplemented by several
* registered classes.
*
* The goal of the library is to make the caretaking of large javascript applications
* easier. At the most basic level, this involves making it easy to add new code
* as classes and objects without creating namespace conflicts, and to do so in a way
* which is natural and easy to follow.
*
* @throws Error AXIS_REG_FAIL
* @throws Error AXIS_BROW_NOT_SUPP
* @throws Error AXIS_FRAMEWORK_LOAD_TIMEOUT
* @throws Error AXIS_ERR_REG_FAIL
* @throws Error AXIS_INCLUDE_SCRIPT_ERROR
* @throws Error AXIS_INCLUDE_SCRIPT_NO_SRC
* @throws Error AXIS_INCLUDE_CSS_ERROR
* @throws Error AXIS_INCLUDE_CSS_NO_HREF
*/
var $AXIS = function()
{
/**
* Check if this is a combined/minified version of the AXIS library
*/
this.minFName = (typeof XMLHTTP == 'function') ? 'AXIS.combined.js' : 'AXIS.js';
/**
* Set up environment info
*/
this.uA = window.navigator.userAgent.toLowerCase();
this.browserVersion = parseFloat(this.uA.match(/.+(?:rv|it|ml|ra|ie)[\/: ]([\d.]+)/)[1]);
this.isSafari = /webkit/.test(this.uA);
this.isOpera = /opera/.test(this.uA);
this.isIE = /msie/.test(this.uA) && !/opera/.test(this.uA);
this.isMoz = /mozilla/.test(this.uA) && !/(compatible|webkit)/.test(this.uA);
this.isWebKit = /AppleWebKit/.test(this.uA);
this.isGecko = /Gecko/.test(this.uA) && (/KHTML/.test(this.uA) === false);
this.isKHTML = /KHTML/.test(this.uA);
this.isMobileSafari = !!this.uA.match(/Apple.*Mobile.*Safari/);
this.isMac = /mac/.test(this.uA);
this.isWindows = /win/.test(this.uA);
this.isLinux = /linux/.test(this.uA);
this.isUnix = /x11/.test(this.uA);
/**
* The shortcut path to the root directory of system (containing such key folders
* as /css, /library, /home, libraries/ etc)
*/
this.ROOT = function()
{
return '/!lime/root/';
};
/**
* Returns the path to a given script.
*
* @param {String} [s] The script filename. Defaults to this.minFName
* @type {String}
* @example: AXIS.PATH('AXIS.js')
* @see #initialize
*/
this.PATH = function(s)
{
var script = s || this.minFName;
var src = this.getScriptSrc(s);
if (src)
return src.replace(new RegExp(script + ".*"), '');
/**
* Script not found, path unknown
*/
return '';
};
this.getScriptSrc = function(s) {
var script = s || this.minFName;
var scripts = document.getElementsByTagName("script");
for(var i=0; i < scripts.length; i++)
{
var src = scripts[i].getAttribute("src");
if (src && src.match(script)) {
return src;
}
}
return '';
}
/**
* Escape CSS selector
*/
this.escapeCSS = function(s) {
return s.replace(/([.:/%* >+~])/g, "\\$1");
}
/**
* General null function, used variously.
*/
this.F = function(){};
/**
*
* @private
* @see #settings
* @see #initialize
*/
/**
merge properties of primary object with secondary
*/
this.merge = function(primary, secondary) {
var result = {};
for(var p in primary) {
result[p] = primary[p];
}
for(var p in secondary) {
result[p] = secondary[p];
}
return result;
};
this._settings = [];
/**
* Accessor for #_settings.
*
* @param {String} q The query property
* @returns The query property value, or false.
* @type {Mixed}
*/
this.settings = function(q)
{
if(q && this._settings[q])
{
return this._settings[q];
}
return false;
};
/**
* @private
* @see #enableNotifications
* @see #disableNotifications
*/
this._notificationsEnabled = true;
/**
* Site data file, used variously, mainly for Login
*
* @private
* @see #initialize
* @see __build__.js
*/
this._siteData = {};
/**
* @private
* @see #contentReady
*/
this._contentReady = false;
/**
* @private
* @see #windowLoaded
*/
this._windowLoaded = false;
/**
* @private
* @see #onContentReady
*/
this._contentReadyFuncs = [];
/**
* @private
* @see #onWindowLoaded
*/
this._windowLoadedFuncs = [];
/**
* @private
* @see #isActivated
*/
this._isActivated = false;
/**
* The css files which every page gets
*
* @private
*/
this._generalCSS = [this.ROOT() + 'css/AXIS.css'];
/**
* These are the objects which together w/ AXIS represent the base framework. Except
* for the special case of the google api, the others are all AXIS objects that
* will be instantiated PRIOR to onContentReady (ie. ready immediately following
* the