/**
* 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.onDOMReady.subscribe({
callback: 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 =
{
/**
* Duplicates a bit: Copies it to the current folder giving it a new name
* args : @bitPath: Path to the bit
* @destFolder : folder where the bit has to be copied
* @options :
* - success : success callback
* - failure : failure callback
* - scope : scope for the callbacks
* TODO : include scope / failure / success callbacks
*/
copy: function(bitPath, destFolder, options)
{
if(!bitPath || !destFolder) {
return;
}
options = options || {};
if(bitPath.charAt(bitPath.length - 1) == '/') {
bitPath = bitPath.substring(0, bitPath.length - 1);
}
AXIS.WebDAV.COPY({
url: bitPath,
destination: destFolder,
tryAlternateNames: true,
on201: function(r) {
if(options.success && ((typeof(options.success)).toLowerCase() == "function")) {
options.success.call(options.scope, r);
}
}
});
},
getBitFromUserDomain: function(bitUrl)
{
AXIS.Cookies.create(bitUrl, "copy", { path: '/!lime/root/apps/bar/' });
location = AXIS._siteData.hosts.limebits + 'apps/copier/#bitUrl=' + encodeURIComponent(bitUrl) +
'&requestor=' + encodeURIComponent('http://'+location.host+'/');
},
getUUID: function(url, callback)
{
AXIS.WebDAV.getProperty({
url: url,
properties: ['resource-id'],
asynch: true,
onSuccess: function(r) {
var resource_id;
try {
resource_id = r.responseXMLObject().multistatus.response.propstat.prop["resource-id"].href.replace(/urn:uuid:/, '').replace(/-/g, '');
}
catch(e) {
resource_id = null;
}
callback(resource_id);
}
});
},
/* copy bitmarks,
options.src_uuid: Set to uuid of source bit
options.url: Set to url of source bit
only one of src_uuid & url is required, src_uuid is preferred
options.destination: Set to url of destination bit
options.dst_uuid: Set to uuid of destination bit
only one of src_uuid & url is required, src_uuid is preferred
*/
copyBitmarks: function(options)
{
if (!options.src_uuid) {
AXIS.Util.bit.getUUID(options.url, function(uuid) {
if (!uuid) {
return options.callback();
}
options.src_uuid = uuid;
AXIS.Util.bit.copyBitmarks(options);
});
}
else if (!options.dst_uuid) {
AXIS.Util.bit.getUUID(options.destination, function(uuid) {
if (!uuid) {
return options.callback();
}
options.dst_uuid = uuid;
AXIS.Util.bit.copyBitmarks(options);
});
}
else {
options.url = '/bitmarks/' + options.src_uuid;
options.destination = '/bitmarks/' + options.dst_uuid;
AXIS.WebDAV.COPY(options);
}
},
getBit: function(bitPath, location_replace)
{
if (AXIS._siteData.hosts.limebits != ("http://" + location.host + "/"))
{
return AXIS.Util.bit.getBitFromUserDomain(bitPath);
}
var bit = AXIS.Util.bit.bitInfo(AXIS.Util.uri.getBitUrl(bitPath));
var user = AXIS.Cookies.read('user');
if (user)
{
var dst_folder = '/home/' + user + '/bits';
AXIS.WebDAV.COPY({
url: bit.tld_root,
asynch: true,
destination: dst_folder + '/' + bit.name,
tryAlternateNames: true,
on201: function(r) {
if (r.alternateName) {
bit.name = r.alternateName;
}
var dstBit = AXIS.Util.bit.bitInfo(AXIS.Util.uri.getBitUrl(r.destination + bit.tld_path_from_root));
AXIS.Cookies.create(dstBit.tld_root, "openConfigure", { path: '/apps/' });
var user_bits_url = "/apps/bitfinder/";
if (location_replace)
top.location.replace(user_bits_url);
else
top.location = user_bits_url;
},
on409: function(r) {
AXIS.WebDAV.MKCOL({
url: dst_folder,
asynch: true,
on201: function(r) {
AXIS.Util.bit.getBit(bitPath, location_replace);
},
onFailure: function(r) {
location.replace(bitPath);
}
});
},
onFailure: function(r) {
var st = r.getStatus();
if(st !== 409 && st !== 412)
{
location.replace(bitPath);
}
}
});
}
else
{
var rand = "" + Math.random();
AXIS.Cookies.create(rand + '-url', AXIS.Util.uri.getUserUrl(bitPath), { path: '/apps/copier/' });
AXIS.Cookies.create(rand + '-confirmed', 'true', { path: '/apps/copier/' });
AXIS.Login.redirReturnTo = AXIS._siteData.hosts.limebits + 'apps/copier/#token=' + rand;
AXIS.Login._redirectToAccess("if_new");
}
},
/*
*/
bitInfo: function(bitUrl)
{
var bit = {};
bit.url = bitUrl;
bit.tld_path = AXIS.Util.uri.getTLDPath(bit.url);
bit.tld_folder = bit.tld_path.match(/.*\//)[0];
bit.filename = bit.tld_path.replace(bit.tld_folder, "");
bit.owner = bit.tld_path.match(/\/home\/([^\/]*)/)[1];
if (bit.tld_path.match(/\/home\/[^\/]*\/bits\/[^\/]*/))
{ /* tld path is of the pattern /home/user/bits/bitname/*** */
bit.tld_root = bit.tld_path.match(/(\/home\/[^\/]*\/bits\/[^\/]*)/)[1];
}
else
{
bit.tld_root = AXIS.Util.uri.chompSlash(bit.tld_folder);
}
bit.tld_path_from_root = bit.tld_path.replace(bit.tld_root, "");
bit.root_url = AXIS.Util.uri.getBitUrl(bit.tld_root);
bit.name = bit.tld_root.replace( /.*\//, "" ); // get the folder basename
return bit;
},
getBitmarks: function(bitFolder, cb)
{
var dav = AXIS.WebDAV;
var marks = {
tags: []
};
dav.SEARCH({
asynch: true,
url: bitFolder,
props: ["displayname", "resource-id", "lastmodified", "popularity"],
bitmarks: {
ns: AXIS.WebDAV.ns.bm,
names: ["tag", "description"]
},
depth: "0",
callback: function(r) {
var resp = r.responseXMLObject().multistatus.response;
var pstat = resp.propstat;
var bstat = resp.bitmarkstat || [];
pstat = AXIS.isArray(pstat) ? pstat : [pstat];
bstat = AXIS.isArray(bstat) ? bstat : [bstat];
for(var j = 0; j < pstat.length; j++)
{
if(pstat[j].status.match(/200 OK/))
{
AXIS.Util.lang.augmentObject(marks, pstat[j].prop);
}
}
for(var k = 0; k < bstat.length; k++)
{
if(bstat[k].status.match(/200 OK/))
{
var bitmark = bstat[k].bitmark;
bitmark = AXIS.isArray(bitmark) ? bitmark : [bitmark];
for(var l = 0; l < bitmark.length; l++)
{
if (bitmark[l].tag)
{
marks.tags.push(bitmark[l].tag);
}
else
{
AXIS.Util.lang.augmentObject(marks, bitmark[l]);
}
}
}
}
cb.call(null, marks)
}
});
},
/**
* Opens the configure tab for a bit.
* Arguments :: @bitPath: Top-level-domain Path to the bit
* Currently this is done by setting a cookie where :
* cookie-name : Absolute URL of the bit
* cookie-value : "new_copy"
*/
openConfigureTab: function( bitPath )
{
if(!bitPath)
return;
var bit = AXIS.Util.bit.bitInfo(AXIS.Util.uri.getBitUrl(bitPath));
// Create the cookie
AXIS.Cookies.create(bit.tld_root, "openConfigure", { path: '/apps/' });
window.location.assign(bit.url + "?bar");
}
};
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(/\/[^\/]*\/?$/, '/');
},
/**
* Normalizes the url by removing redundant slashes (and trailing slashes) and decodes %20
*
* @param {String} url The url to normalize
* @returns The normalized url
* @type {String}
*/
normalize: function(url) {
url = url.replace(/\/\/*/g, "/"); // replace multiple consecutive slashes with one slash
url = url.replace(/%20/g, " "); // decode %20
return AXIS.Util.uri.chompSlash(url); // remove any trailing slashes and return
},
/**
* Removes trailing slashes from the url if present
*
* @param {String} url The url
* @returns The url without any trailing slashes
* @type {String}
*/
chompSlash: function(url) {
return url.replace(/[\/\\]*$/, '');
},
getBitUrl: function(tld_path) {
var bit_info = tld_path.match(/home\/([^\/]+)\/bits\/([^\/]+)(.*)/);
var bit_url;
if (bit_info && bit_info[2].match(/^[-a-z0-9]*$/))
{
bit_url = AXIS._siteData.hosts.limebits.replace("www", bit_info[2] + "." + bit_info[1]) + bit_info[3].substr(1);
}
else
{
bit_url = this.getUserUrl(tld_path);
}
return bit_url;
},
/**
* Converts the www domain path to a FQDN url for accessing the path without redirects
*
* @param {String} tld_path The www domain path of the folder
* @returns The FQDN for accessing that path directly
* @type {String}
*/
getUserUrl: function(tld_path) {
var user_url, user_info;
url_info = tld_path.match(/home\/([^\/]+)(.*)/);
if (url_info)
user_url = AXIS._siteData.hosts.limebits.replace("www", url_info[1]) + url_info[2].substr(1);
else
user_url = AXIS._siteData.hosts.limebits + tld_path.substr(1);
return user_url;
},
/**
* Converts the FQDN url to a www domain path
*
* @param {String} user_url The FQDN for accessing that path directly
* @returns The www domain path of the folder
* @type {String}
*/
getTLDPath: function(user_url) {
var bitParts = user_url.match(/http:\/\/([^\/]+)(\/[^#]*)/);
var hostname_pref = bitParts[1].replace(AXIS._siteData.hosts.limebits.match(/www(\.[^\/]*)/)[1], "");
var bitOwner;
var bitPath = bitParts[2];
if (hostname_pref.split(".").length == 2)
{
bitOwner = hostname_pref.split(".")[1];
return '/home/' + bitOwner + '/bits/' + hostname_pref.split(".")[0] + bitPath;
}
else
{
bitOwner = hostname_pref;
return (bitOwner == 'www') ? bitPath: '/home/' + bitOwner + bitPath;
}
},
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];
}
}
}
this.json =
{
eval: function(text)
{
var json_object = !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(text.replace(/"(\\.|[^"\\])*"/g, ''))) && eval('(' + text + ')');
/*")*/
return json_object;
},
safeEval: function(text)
{
/* comes from JSON.parse at http://json.org/json2.js (public domain). */
var j = {};
var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
cx.lastIndex = 0;
if (cx.test(text))
{
text = text.replace(cx, function (a) {
return '\\u' +
('0000' + a.charCodeAt(0).toString(16)).slice(-4);
});
}
if (/^[\],:{}\s]*$/.test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').replace(/(?:^|:|,)(?:\s*\[)+/g, '')))
j = eval('(' + text + ')');
return j;
}
}
}
/**
* 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) {
var c = o || {};
name = encodeURIComponent(name);
value = encodeURIComponent(value);
c.domain = c.domain ? '; domain=' + encodeURIComponent(c.domain) : '';
c.path = c.path || "/";
if(c.days) {
var date = new Date();
date.setTime(date.getTime()+(c.days*24*60*60*1000));
var expires = "; expires="+date.toGMTString();
}
else {
var expires = "";
}
try {
document.cookie = name+"="+value+expires+"; path=" + c.path + c.domain;
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)
{
/**
* This also requires the developer having set `useGoogleAPI` argument.
* Checks and notifications on failure to do that exist in the
* Module extension.
*
* @see AXIS#Modules#load
*/
AXIS.Modules.load({
provider: 'google',
module: 'gdata',
version: '1',
onload: function(google)
{
console.log(google);
var v = google.loader.ClientLocation;
if(v)
{
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';
};
this.getBitsFolderName = function()
{
return this.isLoggedIn() ? "/home/" + this.username() + "/bits/" : "";
};
};/**
* 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.onDOMReady.subscribe({
callback: function() {
this.loadingPanel = document.body;
this.createLoadingPanel();
},
scope: 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,
UNCHECKOUT: 3,
'VERSION-CONTROL': 3,
TRACE: 3,
BIND: 3,
UNBIND: 3,
REBIND: 3,
MKREDIRECTREF: 3,
OPTIONS: 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)
{
new AXIS.Errors.LoaderException('XHR_NO_URL_SENT');
return false;
}
a.method = (a.method) ? a.method.toUpperCase() : 'GET';
a.url = a.url;
a.breakCache = !!a.breakCache;
a.callback = a.callback || AXIS.F;
a.onSuccess = a.onSuccess || AXIS.F;
a.onFailure = a.onFailure || AXIS.F;
a.onBeforeSend = a.onBeforeSend || AXIS.F;
a.onAfterSend = a.onAfterSend || 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 || {};
/**
* Keep a non-translated version of the request url in case we want
* to fetch that info later
*/
a.origRequestUrl = a.url;
/**
* 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 XHR#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 XHR()
{
/**
* @constructor
*/
this.__construct = function()
{
/**
* The headers that will be sent with every request, unless overridden
*
* @see #send
*/
this.defaultHeaders =
{
'X-Requested-With': 'XMLHttpRequest',
'Accept': 'text/javascript, text/plain, text/html, text/xml, application/javascript, application/json, application/xml, */*'
};
/**
* 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.XHR.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#XHR#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] || (AXIS.isString(nf[ns]) ? function()
{
new AXIS.Errors.XHRException(nf[ns]).report();
} : 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 #XHR). 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;
var st = hh.status;
/*
* TODO: testing xbrow
*/
if((!st && location.protocol == 'file:') || st)
{
/**
* Check for IE oddity of creating status `1223` when
* correct is `204`. Simply return reset value
*/
if(st == 1223)
{
return 204;
}
/**
* An unfortunate hack for Safari && Opera.
* Safari sets a status of 404 when receiving 401 responses.
* Opera will set a status of 403 when receiving 401.
* Safari also destroys headers.
* Our auth (401) pages send HTML w/ `401`.
* The solution is to determine if, based on responseText,
* we have received a 401. Override whatever status is
* sent should this be the case. This is done for all
* browsers, to avoid ongoing browser-specific forking. As
* Chrome's implementation of Webkit doesn't have the same
* bug, the hope is that it is known and will go away.
*/
if((st == 404 || st == 403) && hh.responseText.indexOf('401') !== -1)
{
return 401;
}
/**
* Only return on acceptable status codes
*/
if(AXIS.XHR.statusCodes[st])
{
return st;
}
}
return false;
},
getResponseHeader: function(h)
{
if(h && AXIS.isString(h))
{
var rh = this.httpHandle.getResponseHeader(h);
/**
* Special case: In cases where the returned body is gzipped, the
* server will append a suffix '-gzip' to the Etag. This causes
* trouble if this suffixed Etag is used later to run update checks,
* such as when we want to check if a file has been updated since the
* current local representation was loaded. If we set a header precondition
* (If-Match: Etag) on a PUT, the Etag reported to PUT will *not* have a
* suffix, and as such will *always* be different than the original
* suffixed Etag, even if the file itself has not changed. So... we strip
* out '-gzip' from Etag requests.
*/
if(rh !== null && h == 'Etag')
{
return rh.replace('-gzip','');
}
return rh;
}
return null;
},
lifespan: a.lifespan || AXIS._maxXHRLifespan,
onBeforeTimeout: a.onBeforeTimeout || function()
{
new AXIS.Errors.XHRException('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(inf)
{
if(this.httpHandle.readyState === 4)
{
var T = this;
AXIS.Shell.log('axis','debug','Received ', T);
/**
* 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 ? T.responseXML.xml : (new XMLSerializer()).serializeToString(T.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.XHR.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.getResponseHeader("Etag");
}
catch(e)
{
T.__ETAG__ = '"0"';
}
AXIS.XHR.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);
/**
* If a status code that the user has defined as a failure code is
* caught, fire the #onFailure handler. If status is not returned or
* a > 400 level Http status code is returned, we understand this
* as being a failure, and we fire the #onFailure handler.
*/
if(T.failureCodes[stat] || stat === false || stat > 400)
{
T.onFailure.call(T.scope, T, procResp);
}
/**
* If not a failure, check success status, and fire any
* relevant success handlers.
*/
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];
}
/**
* 204's in IE cause trouble... mainly, an httpHandle.send does
* not return at point of send. So we force the readystate handler
* into the duty of calling #main.
*/
xob.httpHandle.onreadystatechange = AXIS.isIE &&
a.asynch === false &&
a.method === 'PUT'
? function() { xob.main() }
: AXIS.F;
return(xob);
};
this.send = function(a)
{
var CB = this.build(a);
var targUrl = CB.url;
AXIS.Shell.log('axis','debug','Sending ',CB);
/**
* To break cache we're just adding a random query. Check if
* request has query fragment, and if so, append, if not, create.
*/
if(CB.breakCache)
{
targUrl = (CB.url.indexOf('?') !== -1)
? CB.url + AXIS.getUniqueId('&')
: CB.url + AXIS.getUniqueId('?');
}
/**
* This scope will be applied to the response handlers, if any.
* Default scope is the call object itself.
*
* @see #build#main
*/
CB.scope = CB.scope || CB;
CB.httpHandle.open(CB.method, targUrl, 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
*/
if(this.cache[CB.url])
{
CB.headers["If-None-Match"] = this.cache[CB.url].__ETAG__;
}
}
/**
* 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.onBeforeSend.call(CB.scope,CB);
CB.httpHandle.send(CB.body);
CB.onAfterSend.call(CB.scope,CB);
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()
{
/**
* namespaces that should be useful to users
* use like AXIS.WebDAV.ns.lb
*/
this.ns = {
d: 'DAV:',
lb: 'http://limebits.com/ns/1.0/',
bm: 'http://limebits.com/ns/bitmarks/1.0/'
};
this.currentProperties = [];
/**
* 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';
AXIS.Errors.registerCode('DAV_ACE_CONFLICT', "An ace conflict occured");
AXIS.Errors.registerCode('DAV_ACE_INVALID_PRIVILEGES', "Privileges argument is invalid.");
AXIS.Errors.registerCode('DAV_ACL_CANNOT_REMOVE_INHERITED_ACE', "Inherted aces can only be removed on the ancestor.");
AXIS.Errors.registerCode('DAV_ACL_CANNOT_REMOVE_PROTECTED_ACE', "Protected aces cannot be removed.");
AXIS.Errors.registerCode('DAV_ACL_CORRUPTED', "The acl has been corrupted. Have you been editing it directly? ");
AXIS.Errors.registerCode('DAV_ACL_CHANGED', "The resource's acl has changed since you last fetched it. Try again and use a lock if possible.");
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", "is_bit"];
var comparisonGenerator = function(oper) {
// OK, so the search only searches for s. We need to add search support based on bitmarks
// searchCriteria currently has two members: @name : name of the tag whose value is to be searched
// @ns : namespace for the tag
search[oper] = function(prop, literal, searchCriteria) {
if(searchCriteria) {
startTag = "S:" + searchCriteria.name + " xmlns:S='" + searchCriteria.ns + "'";
endTag = "S:" + searchCriteria.name;
}
else {
startTag = "prop";
endTag = "prop";
}
if (oper === "is_defined")
return "<" + startTag + ">" + search._prop_to_xml(prop) + "";
if (oper === "is_collection")
return "";
if (oper == "is_bit")
return "";
if (literal !== undefined) {
if (oper.indexOf("i") === (oper.length - 1)) {
oper = oper.slice(0, -1);
literal = '' + literal + "";
} else {
literal = "" + literal + "";
}
}
return "<" + oper + "><" + startTag + ">" + search._prop_to_xml(prop) + "" + literal + "";
}
}
for (var i=0; i < comparisonOps.length; i++) {
comparisonGenerator(comparisonOps[i])
};
};
/**
* 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 XHR 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).
*/
/**
* 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;
d.ifExists = d.ifExists === undefined ? false : true;
d.headers = {
Timeout: d.timeout,
Depth: d.depth
};
/**
* If-Match will stop a lock from being taken on an unmapped
* url -- which would normally create an locked, empty, resource.
*/
if(d.ifExists)
{
d.headers['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 + '\
';
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': '<' + d.locktoken + '>'
};
AXIS.XHR.setStatusHandlerForResponse(d,
{
400: 'DAV_UNLOCK_400~~' + d.url,
403: 'DAV_UNLOCK_403~~' + d.url,
409: 'DAV_UNLOCK_409~~' + d.url
});
return this.send(d);
};
/**
* @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.
*
* Some possible other headers:
* Apply-To-Redirect-Ref: T
*/
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/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.XHR.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';
d.headers = dav.headers || {};
AXIS.XHR.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)
{
new AXIS.Errors.DAVException('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;
var depth = (d.headers && d.headers.Depth) ? d.headers.Depth : 'infinity';
if(d.destination === undefined)
{
new AXIS.Errors.DAVException('DAV_COPY_NO_DESTINATION');
return false;
}
d.headers = {
Destination: d.destination,
Overwrite: d.overwrite ? 'T' : 'F',
Depth: depth
};
AXIS.XHR.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,
asynch: d.asynch,
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,
asynch: d.asynch,
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)
{
new AXIS.Errors.DAVException('DAV_MOVE_NO_DESTINATION');
return false;
}
d.headers = {
Destination: d.destination,
Overwrite: d.overwrite ? 'T' : 'F',
Depth: d.depth || 'infinity'
};
AXIS.XHR.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.UNCHECKOUT = function(dav)
{
var d = dav || {};
d.method = "UNCHECKOUT";
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.
*
* @param {Object} dav.bitmarks :: An object containing the bitmarks to be obtained
* with the resources themselves
*
* dav.bitmarks.ns: {String} Namespace for the bitmarks
* dav.bitmarks.bitmarks: {Array} List of bitmarks to fetch
*
*/
this.SEARCH = function(dav)
{
// utility
var _prop_to_xml = this.SEARCH._prop_to_xml;
// options
var d = dav || {};
d.props = d.props || ["allprop"],
d.depth = d.depth || 1,
d.where = d.where || null,
d.limit = d.limit || null,
d.offset = d.offset || null,
d.orderby = d.orderby || null,
d.bitmarks = dav.bitmarks || null;
d.url = d.url;
d.method = "SEARCH";
/*
xml builder functions
*/
// TODO this could probably be abstracted out a bit
var builder = {
defaultNS : AXIS.WebDAV.ns.bm,
_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 + '';
}
},
_bitmarkXML: function() {
/*
* bitmark xml is of the form :
*
*
*
*
*
*/
var retString = '';
var bmarks = d.bitmarks;
if( bmarks ) {
var bitmarkXML = [];
var bitmarkNS = d.bitmarks.ns || this.defaultNS;
bitmarkXML.push("");
var bitmarkTemplate = "";
var bitmarkNames = bmarks.names;
for(var i = 0; i < bitmarkNames.length; i++) {
bitmarkXML.push( bitmarkTemplate.replace(/name/g, bitmarkNames[i]) );
}
bitmarkXML.push("");
retString = bitmarkXML.join("");
}
return retString;
},
_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);
};
/**
* 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)
{
new AXIS.Errors.DAVException('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);
};
/**
* @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/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-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);
};
/**
* 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.setProperties)
{
d.setProperties = (AXIS.isArray(d.setProperties)) ? d.setProperties : [d.setProperties];
}
else
{
new AXIS.Errors.DAVException('DAV_BAD_PROPSET_ARGS');
return false;
}
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.removeProperties)
{
d.removeProperties = (AXIS.isArray(d.removeProperties)) ? d.removeProperties : [d.removeProperties];
}
else
{
new AXIS.Errors.DAVException('DAV_BAD_PROPREMOVE_ARGS');
return false;
}
return this.PROPPATCH(d);
};
this.getProperty = function(dav)
{
var d = dav || {};
var props = d.properties || [];
var xml = "";
var prop;
/**
* Allowed to send a single property object, or array
*/
props = AXIS.isArray(props) ? props : [props];
for(var i=0; i < props.length; i++)
{
prop = props[i];
/**
* Also want to allow the sending of a simple property string
* if only sending a property name. Instead of:
* [{name: 'propname'}]
* send:
* ['propname']
*/
prop = AXIS.isObject(prop) ? prop : {name:prop};
prop.ns = prop.ns || 'DAV:';
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);
};
/**
* Does a PROPFIND with . Allows inclusion ().
*
* DAVObject {
* .url: 'foo.html',
* .includes: [
* 'supported-live-property-set',
* 'supported-report-set'
* ]
* }
*
* @href http://greenbytes.de/tech/webdav/rfc4918.html#rfc.section.9.1.5
* @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.getAllProperties = function(dav)
{
var d = dav || {};
d.body = '\
\
';
if(d.includes && AXIS.isArray(d.includes))
{
d.body += '';
for(var i=0; i < d.includes.length; i++)
{
d.body += '';
}
d.body += '';
}
d.body += '';
return this.PROPFIND(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.readFolder = function(dav)
{
var d = dav || {};
var withCups = !!dav.withCups;
d.body = '\
\
';
if(withCups)
{
d.body += ' \
\
';
}
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.responseProcessor || AXIS.F;
d.responseProcessor = function(r)
{
var resObBuild = function(resOb)
{
/**
* Check the response. If with Cups, then each response
* object will contain two propstat responses, meaning that
* response.propstat will be an Array; if not with Cups, then
* it is not. Check for this, and build the return object
* with added Cups info, if required.
*/
var rPS = resOb.propstat;
var wC = AXIS.isArray(rPS);
var rP = wC ? rPS[0] : rPS;
var rC = wC ? rPS[1] : rPS;
var ret =
{
properties: rP.prop,
href: resOb.href,
type: rP.prop.resourcetype ? 'collection' : 'file'
};
if(wC)
{
var cOb = function(c)
{
this.privileges = {};
for(w=0; w < c.length; w++)
{
/**
* An unfortunate consequence of the
* way that responseXMLObject() works...
*/
for(var s in c[w])
{
this.privileges[s] = true;
}
}
this.hasPrivilege = function(p)
{
p = p || 'x';
return this.privileges.hasOwnProperty(p);
};
};
ret.Cups = new cOb(rC.prop['current-user-privilege-set'].privilege);
}
return ret;
}
try
{
var st = r.responseXMLObject().multistatus.response;
var res = AXIS.isArray(st) ? st : [st];
/**
* The [0] element is the folder info itself.
*/
r.folder = resObBuild(res[0]);
r.folder.children = [];
/**
* Build the result list, pushing the resource object's propstat.prop(s).
* Note that we are adding the #href and #type properties to each resource
* object. The resource at [0] index is the original called resource, so
* we start at [1].
*/
for(var x=1; x < res.length; x++)
{
r.folder.children.push(resObBuild(res[x]));
}
}
catch(e){};
c2(r);
}
return this.PROPFIND(d);
};
this.emptyFolder = function(dav)
{
var d = dav || {};
if(AXIS.isString(d.url) === false)
{
return;
}
var f = this.readFolder({
url: d.url,
onSuccess: function(r)
{
var fL = r.folder.children;
for(var x=0; x < fL.length; x++)
{
AXIS.WebDAV.DELETE({
url: fL[x].href
});
}
}
});
};
/**
* Checks if a file exists. Note that this is a forced synchronous
* call, a PROPFIND, that returns an object containing information about
* resource:
*
* {String} resourcetype One of 'collection' or 'file'.
* {String} contenttype 'text/html', 'applications/javascript'...
* {Boolean} success Whether file was found.
*/
this.fileInfo = function(dav)
{
var d = dav || {};
return AXIS.WebDAV.getProperty({
url: d.url,
asynch: !!d.asynch, // note that this defaults to false
properties: [ 'getcontenttype',
'resourcetype'
],
callback: d.callback || AXIS.F,
responseProcessor: function(r) {
var rX, txt;
r.success = false;
r.contenttype = null;
r.resourcetype = 'file';
r.Caller = r
if(r.getStatus() === 207)
{
/**
* Fetch correct nodes from returned document.
*/
var rType = AXIS.Util.xml.getChildrenByNameNS(r.responseXML.documentElement, 'resourcetype');
var cType = AXIS.Util.xml.getChildrenByNameNS(r.responseXML.documentElement, 'getcontenttype');
/**
* #resourcetype set to 'collection' or 'file'.
*/
if(rType[0].firstChild)
{
if(rType[0].firstChild.nodeName === 'D:collection')
{
r.resourcetype = 'collection';
}
else
{
r.resourcetype = 'file';
}
}
else
{
txt = AXIS.Util.xml.getText(rType[0]);
r.resourcetype = txt === 'collection'
? 'collection'
: 'file'
}
r.contenttype = cType[0] ? AXIS.Util.xml.getText(cType[0]) : '';
r.success = true;
}
}
});
};
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);
}
/***********************************
* START ACL
***********************************/
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 = [];
this.protectedAces.makeAce = this.editableAces.makeAce = this.inheritedAces.makeAce = Acl.prototype.makeAce;
this.protectedAces.findAces = this.editableAces.findAces = this.inheritedAces.findAces = Acl.prototype.findAces;
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(true);
},
/**
* 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
new AXIS.Errors.DAVException('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 (ace.grant == null || 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;
},
isGrantedRead: function(principal)
{
var matchingAces = this.findAces(null, ['read', 'all'], principal);
if (matchingAces.length)
return matchingAces[0].grant;
return false;
},
/**
* 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]))
new AXIS.Errors.DAVException('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)
new AXIS.Errors.DAVException('DAV_ACL_CANNOT_REMOVE_PROTECTED_ACE');
if (this[index].inherited)
new AXIS.Errors.DAVException('DAV_ACL_CANNOT_REMOVE_INHERITED_ACE');
var edIndex = index - this.protectedAces.length;
if (this[index] != this.editableAces[edIndex])
new AXIS.Errors.DAVException('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.splice(0, this.editableAces.length);
if (this.length != this.protectedAces.length + this.inheritedAces.length)
new AXIS.Errors.DAVException('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)
new AXIS.Errors.DAVException("DAV_ACL_CHANGED");
var acl = d.acl.printXML(true);
d.body = '' + acl;
return AXIS.WebDAV.send(d);
}
});
};
/*******************************
* END ACL
*******************************/
/**
* 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 || {};
/*
* 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
* @modified Sandro Pasquali - repackaged as XHR response handler
*/
this._responseXMLObject = function(withAtts)
{
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.registerCode('LB_LOGOUT_INVALID_SIGNOUT', "Couldn't log out of all domains");
this.onAuthUpdate = AXIS.CustomEvent.create();
this.beforeLogout = AXIS.CustomEvent.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.onDOMReady.subscribe({
callback: function() {
this._createAutoLoginFrame();
this.login();
},
scope: 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()
{
try
{
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;
this._loginFrameWindow.location.replace("about:blank");
AXIS.attachEvent('load',this._loadFrameHandler,frm);
}
catch(e){}
};
/**
* 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":
new AXIS.Errors.LoginException('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_ERR_REG_FAIL
* @throws Error AXIS_INCLUDE_SCRIPT_NO_SRC
* @throws Error AXIS_INCLUDE_CSS_NO_HREF
*/
var $AXIS = function()
{
/**
* Check if this is a combined/minified version of the AXIS library. The check
* is for existence of XHR extension. Loose, but unlikely that the combined
* AXIS will not have this extension, as it is necessary for most everything.
*/
this.minFName = (typeof XHR == '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);
this.isIPhone = /iPhone/.test(this.uA);
this.isIPod = /iPod/.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 '';
};
/**
* Returns a reference to the SCRIPT element whose source contains
* the string argument.
*
* @param {String} s The string to search for in the .src attributes
* of the SCRIPTS collection. Normally, this would
* be a js filename, like AXIS.js
*/
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 '';
};
/**
* General null function, used variously.
*/
this.F = function()
{
return false;
};
/**
* @see #attachEvent, #detachEvent
*/
this.IE_EVENTS = [];
/**
* Interface to the Shell object, which handles ! requests. The main purpose
* is to allow the Shell object code itself to be loaded only when needed. Code
* is loaded once first call to #run is received.
*
* @see #onHashChange
* @see shell/Shell.js
*/
this.Shell =
{
run: function(cmd)
{
var r = function()
{
AXIS.Shell._run(cmd || false);
};
if(AXIS.isUndefined(this._run))
{
AXIS.includeScript({
src: AXIS.PATH() + '/shell/Shell.js',
onload: r
});
}
else
{
r();
}
},
log: function() {}
};
/**
*
* @private
* @see #settings
* @see #initialize
*/
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
*/
this._notificationsEnabled = true;
/**
* Site data file, used variously, mainly for Login
*
* @private
* @see #initialize
* @see __build__.js
*/
this._siteData = {};
/**
* 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.
* You may add other scripts.
* NOTE: order is important. Be sure to leave Login.js as the very last.
*
* In order to be included in AXIS.combined.js, be sure to put your script on a separate
* line and have your line be of the form "this.PATH() + 'yourscript.js'".
*
* Please do not remove the BEGIN LIMEBITS_.... line below. It is used by our Rakefile
* to identify where to start parsing out the names of the scripts to include in
* AXIS.combined.js
*
* BEGIN LIMEBITS_SITE_AXIS_COMBINED_FRAMEWORK_LIST
*
* @private
*/
this._framework = [
this.PATH() + 'Util.js',
this.PATH() + 'Cookies.js',
this.PATH() + 'User.js',
this.PATH() + 'Loader.js',
this.PATH() + 'XHR.js',
this.PATH() + 'WebDAV.js',
this.PATH() + 'Login.js'
];
/* END LIMEBITS_SITE_AXIS_COMBINED_FRAMEWORK_LIST */
/**
* Error handling/debugging for the AXIS is enabled by loading the
* `Errors` extension. Errors are reported in this system by adding
* commands like: new AXIS.Errors.AXISException('exception info') to
* your code. It wouldn't be reasonable to expect these commands to
* be removed from the code when not in debugging mode. However, they
* make no sense unless the Errors extension is loaded: if it is not
* loaded, AXIS.Errors does not exist, resulting in an non-existent
* method javascript error. The below exists, therefore, to "catch"
* those debug commands when the Errors extension is not enabled.
* Note that the methods of this dummy class do nothing.
*/
this.Errors =
{
createExceptionType: function(ex)
{
AXIS.Errors[ex] = function()
{
this.report = function(){};
};
},
registerCode: this.F,
setReportingLevel: this.F
};
this.createCoreErrorTypes = function()
{
/**
* @see #Errors
*/
AXIS.Errors.createExceptionType('AXISException');
AXIS.Errors.createExceptionType('XHRException');
AXIS.Errors.createExceptionType('LoginException');
AXIS.Errors.createExceptionType('LoaderException');
AXIS.Errors.createExceptionType('DAVException');
};
/**
* Interface to the Shell object, which handles ! requests. The main purpose
* is to allow the Shell object code itself to be loaded only when needed. Code
* is loaded once first call to #run is received.
*
* @see #onHashChange
* @see shell/Shell.js
*/
this.Shell =
{
run: function(bang)
{
var r = function()
{
/**
* Parse out the request. Simply want to ensure that the shell
* receives a string command, and an array of arguments. Format is:
* !command:arguments&split&on&ersand.
*
* If arguments are sent, the regex match will return a captured group
* array, where command is [2] and arguments are [3]. No arguments or other
* failure of outer capturing group we get null, which means no args (no :)
*/
var i = bang.match(/^((.*):{1}(.*))$/);
var c = i === null ? bang : i[2];
var a = i === null ? [] : i[3].split('&');
AXIS.Shell._run(c,a);
};
if(AXIS.isUndefined(this._run))
{
AXIS.includeScript({
src: AXIS.PATH() + '/shell/Shell.js',
onload: r
});
}
else
{
r();
}
},
log: function() {}
};
/**
* A reference to every script include object is registered here, indexed by its .id.
*
* @private
* @see #includeScript
*/
this._registeredScripts = [];
/**
* A reference to every css include object is registered here, indexed by its .id.
*
* @private
* @see #includeCSS
*/
this._registeredStyleSheets = [];
/**
* The # of ms that an XHR request will poll for readystate 4 before dying.
*
* @private
* @see Queue#add
* @see XHR#build
*/
this._maxXHRLifespan = 15000;
/**
* The # of ms that a notification stays visible prior to fading.
*
* @private
* @see #showNotification
*/
this._notificationFadeDelay = 20000;
/**
* ID and CLASS attributes of the DOM containers for messages (both
* notifications and loading messages). These should be defined in base.css.
*
* @see Loader#load
* @see Loader#createLoadingPanel
* @see Loader#updateLoadingPanel
* @see Loader#clearLoadingPanelItem
* @see #showNotification
*/
this.loadingMsgContainerId = 'AXIS_loading_panel';
this.loadingMsgItemClass = 'AXIS_loading_panel_item';
this.defaultLoadingMsg = 'Loading...';
this.notificationContainerId = 'AXIS_notification_container';
this.notificationItemClass = 'AXIS_notification';
this.notificationCloseButtonClass = 'AXIS_notification_close_button';
/**
* Ms fade runs in #fadeTo
*
* @see #fadeTo
*/
this.defaultFadeSpeed = 500;
/**
* Readable Node values
*/
this.ELEMENT_NODE = 1;
this.ATTRIBUTE_NODE = 2;
this.TEXT_NODE = 3;
this.CDATA_SECTION_NODE = 4;
this.ENTITY_REFERENCE_NODE = 5;
this.ENTITY_NODE = 6;
this.PROCESSING_INSTRUCTION_NODE = 7;
this.COMMENT_NODE = 8;
this.DOCUMENT_NODE = 9;
this.DOCUMENT_TYPE_NODE = 10;
this.DOCUMENT_FRAGMENT_NODE = 11;
this.NOTATION_NODE = 12;
/**
* Escape CSS selector
*/
this.escapeCSS = function(s)
{
return s.replace(/([.:/%* >+~])/g, "\\$1");
};
/**
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;
};
/**
* Will parse any string sent as one having a possible querystring -- that a `?`
* character exists after which there are query arguments, in the format one
* would expect with standard http querystrings. If such a querystring is found,
* it will be parsed. An example:
*
* general.js?specialArgs=one+two+three&moreArgs=foobar
*
* - `specialArgs` will be a new index in returned array;
* - `+` is coverted to space ` `, so value of `specialArgs` is
* a string with spaces: `one two three`;
* - `moreArgs` is another key in returned array, value `foobar`.
*
* @param {String} qst A string.
* @returns An array filled as described above.
* @type {Array}
* @see #initialize
*/
this.fetchBuildArguments = function()
{
var ret = [];
var i, j, src, s, args;
var scripts = document.getElementsByTagName("*");
for(i=0; i < scripts.length; i++)
{
src = scripts[i].src;
if(src && src.match(this.minFName))
{
args = scripts[i].getAttribute('arguments');
args = args ? args.split('+') : [];
ret.extensions = scripts[i].getAttribute('extensions') || '';
ret.libraries = scripts[i].getAttribute('libraries') || '';
for(j=0; j < args.length; j++)
{
s = args[j].split('=');
ret[s[0]] = s[1] || true;
}
this._settings = ret;
break;
}
}
};
/**
* Extension of the AXIS is done by registering classes via this function. Any
* class so registered inherits (via prototype chain) this method, allowing the
* registered class to further register `subclasses`.
*
* @param {String} scr A String representation of the class to be registered
*/
this.register = function(scr)
{
/**
* Do not re-register. NOTE: The Errors extension is a special case. AXIS
* has a "dummy" Errors object, which handles bug reports quietly when
* the actual Errors extension is not requested. So, if the user has
* requested the Errors extension, given below, it won't actually be loaded,
* as there already exists the mentioned dummy Errors object.
*/
if(AXIS.hasOwnProperty(scr) && (scr != 'Errors'))
{
return this[scr];
}
if(window[scr])
{
/**
* Set prototype of object definition to caller
*/
window[scr].prototype = this;
/**
* Add new object to this collection
*/
this[scr] = new window[scr];
/**
* If `createGlobals` has been passed via query, set global.
* NOTE: What you are doing by creating globals is creating a shortcut
* to any registered framework object in the global namespace. For example,
* if you register an object `MyStuff`, which when registered is now
* accessbible via `AXIS.MyStuff`, you will also be able to access it
* via `$$Mystuff`. This should be ok, but in general globals can cause
* conflicts, so it is up to you to make sure you aren't creating collisions.
*
* @see #PATH
* @see #initialize
*/
if(this.settings('createGlobals'))
{
window['$$' + scr] = this[scr];
}
/**
* Mark original class def for cleanup
*/
window[scr] = null;
/**
* Call constructor, if any.
*/
this[scr].__construct && this[scr].__construct();
return this[scr];
}
return null;
};
/**
* Namespace storage.
*
* @param {String} ns The namespace, form of `chain.like.this`, which
* creates $AXIS.chain.like.this namespace.
* @type {Mixed} NS ref if successful; false if not.
*/
this.createNamespace = function(ns)
{
var a = arguments;
var x, y, f, i, z;
if(a.length === 0)
{
return false;
}
/**
* Allowing for multiple namespace strings to be sent
*/
for(i=0; i < a.length; i++)
{
x = a[i].split(".");
y = $AXIS;
for(z=0; z < x.length; z++)
{
/**
* Simply adding to the chain, and repointing y to the new node.
* NOTE that pre-existing nodes are preserved.
*/
y = y[x[z]] = y[x[z]] || {};
}
}
/**
* Note that in case of multiple NS strings, only the first
* resolved NS will be returned.
*/
return eval('$AXIS.' + ns);
};
/**
* Shows a notification message. The behaviour is as follows:
* 1. Show notification and set its fading behaviour. The default of the
* AXIS is to have an absurdly large delay before fading (24 hours), which
* means the user will not miss the notification if away from desk. You
* can change this value via .setNotificationDelay().
* 2. Each notification is given a dismiss button ('OK') to its rightmost, and
* clicking this button will get rid of not only the current notice, but
* ALL notices. This follows the logic of next behaviour.
* 3. Any click on the screen will terminate all existing notices.
*
* NOTE that the notification is only shown after content is ready.
*
* @param {Object} v The notification info object:
* {
* content {String} The content of the message. Can be HTML.
* button {Boolean} Whether to show a close button. Default true.
* onDismiss {Function} A function to execute when notification dismissed.
* type {String} The type of notification (TODO)
* }
*/
this.showNotification = function(v)
{
if(v && v.content && this._notificationsEnabled)
{
AXIS.onDOMReady.subscribe({
callback: function()
{
var b = v.button || true;
var t = v.type || 'default';
b = b ? '' : '';
var n = AXIS.find(AXIS.notificationContainerId);
var d = n.appendChild(document.createElement('div'));
d.id = AXIS.getUniqueId('notification_');
d.className = AXIS.notificationItemClass;
d.innerHTML = v.content + b;
var f = AXIS.fadeTo({
'element': d,
startDelay: AXIS._notificationFadeDelay,
deleteOnEnd: true
});
d.nClose = function(e) {
AXIS.detachEvent('click',d.nClose);
f.forceFade();
v.onDismiss && v.onDismiss();
}
/**
* This event will force a close of all visible notifications.
* You can change the event, or simply comment this out.
*/
AXIS.attachEvent('dblclick',d.nClose,n);
}
});
}
};
/**
* Creates a unique id, suitable for id="" usage, and elsewhere
* @param {String} pref An optional prefix. defaults to 'id_'
* @return A unique id
* @type String
*/
this.getUniqueId = function(pref)
{
var d = new Date;
return (pref || 'id_') + parseInt(Math.random(d.getTime())*Math.pow(10,10));
};
/**
* onDOMReady
* Copyright (c) 2009 Ryan Morr (ryanmorr.com)
* Licensed under the MIT license.
*
* Cosmetic changes to cut bytes. Also: Original code had legacy
* browsers hijacking window.onload. This has been removed.
*/
this._onContentReady = function()
{
var ready, timer;
var D = document;
var hasFired = false;
var onStateChange = function(e)
{
// moz && opera
if(e && e.type == "DOMContentLoaded")
{
dR();
}
else if(D.readyState)
{
// safari & ie
if((/loaded|complete/).test(D.readyState))
{
dR();
//IE, courtesy of Diego Perini (http://javascript.nwbox.com/IEContentLoaded/)
}
else if(!!D.documentElement.doScroll)
{
try
{
ready || D.documentElement.doScroll('left');
}
catch(e)
{
return;
}
dR();
}
}
};
var dR = function()
{
if(!D.body)
{
return;
}
if(!ready)
{
ready = true;
/**
* Create the notification element.
*
* @see #showNotification
*/
var n = D.body.appendChild(D.createElement('div'));
n.id = AXIS.notificationContainerId;
AXIS.onDOMReady.fire();
/**
* DOM cleanup
*/
if(D.removeEventListener)
{
D.removeEventListener("DOMContentLoaded", onStateChange, false);
}
D.onreadystatechange = null;
clearInterval(timer);
timer = null;
}
};
// Mozilla & Opera
if(D.addEventListener)
{
D.addEventListener("DOMContentLoaded", onStateChange, false);
}
// IE
D.onreadystatechange = onStateChange;
// Safari & IE
//timer = setInterval(onStateChange, 5);
};
/**
* Sets up a system whereby the hash fragment is watched, and any changes are
* broadcast to subscribers of AXIS#onHashChange. NOTE: To disable the watcher,
* simply pass `disableHashWatcher` argument to AXIS.
*
* @see #initialize
*/
this.createHashWatcher = function()
{
AXIS.onHashChange = AXIS.CustomEvent.create();
AXIS.onHashChangeWatcher = AXIS.Queue.add({
currentHash: null,
lastHash: null,
command: null,
main: function() {
var splt, cmd, z, x, s;
var args = {};
var u = AXIS.parseUrl();
var hsh = u.fragment;
var bang = u.url.lastIndexOf('!');
this.currentHash = hsh;
if(AXIS.settings('disableHashWatcher'))
{
return false;
}
if(!!hsh && this.lastHash !== hsh)
{
/**
* Don't want to change lastHash if command.
*/
if(bang === -1)
{
this.lastHash = hsh;
}
/**
* We now have a command, and any arguments. Pass
* this to the hash handler.
*/
splt = hsh.split('&');
cmd = splt.shift();
/**
* Store, so that apps can use #onHashChangeWatcher reference
* to check for latest command.
*/
this.command = cmd;
/**
* Create args object.
*/
for(x=0; x < splt.length; x++)
{
s = splt[x].split('=');
args[s[0]] = s[1];
}
/**
* Commands that begin with a ! are internal. Others
* are passed on to listeners.
*/
if(bang !== -1)
{
/**
* Because this framework may well run alongside other code that
* itself might be checking for hash changes, want to clear away
* the command, to avoid corrupting such data.
*/
window.location.replace(u.url.substring(0,bang));
/**
* Now send command to shell.
*/
AXIS.Shell.run(u.url.substring(bang +1,u.url.length));
}
else
{
AXIS.onHashChange.fire({
command: cmd,
args: args
});
}
}
return true;
}
});
};
/**
* Determines paths to files needed to satisfy AXIS directes `extensions` and
* `libraries`. Expects an array reference to push these results onto.
*
* NOTE: The filenames given in attributes `libraries` and `extensions` are
* by default expected to exist within the folder containing the AXIS. It is likely
* that you may want to create custom extensions and libraries which will not
* exist in the AXIS folder. To do that, you simply prepend a tilde(~) to the
* library/extension name, followed by the path (either relative, or absolute).
* Such as:
* libraries="array+string+~mylibrary/foo/bar/file.js+~http://www.foo.com/bar.js
*
* @param {Array} ret An array to push resolved paths onto
* @param {String} qN A directive string ("foo+bar...");
* @param {String} aP Added subpath (ie 'libraries', which means axis/libraries/)
* @see #initialize
*/
this.buildPathForDirective = function(ret,qN,aP)
{
var f, i;
var a = qN ? qN.split('+') : [];
var aPath = aP ? aP + '/' : '';
for(i=0; i < a.length; i++)
{
if(a[i].charAt(0) == '~')
{
f = a[i].substring(1,a[i].length);
}
else
{
f = AXIS.PATH() + aPath + a[i] + '.js';
}
ret.push(f);
}
};
/**
* Upon instantiation of AXIS object (see bottom of file), a call to #initialize
* is made, which:
* - Sets a timeout to handle framework loading timeouts;
* - Calls #PATH on AXIS.js, which is done to fetch any query args regarding
* requested extensions to AXIS;
* - Add any extensions to the core #_framework array;
* - Load all core files, including extensions, and when they are loaded, load
* the initialization script (__build__.js), which does registration of objects,
* fetches user domain data, fetches user data via google api, and calls #start.
*
* @see __build__.js
* @throws AXIS_FRAMEWORK_LOAD_TIMEOUT
*/
this.initialize = function()
{
AXIS.createCoreErrorTypes();
/**
* Fired when the AXIS is loaded, initialized... ready
*
* @see AXIS#start
*/
AXIS.onReady = AXIS.CustomEvent.create({
name: 'onReady'
});
/**
* Fires when the DOM is ready for manipulation
*
* @see AXIS#_onContentReady
*/
AXIS.onDOMReady = AXIS.CustomEvent.create({
name: 'onDOMReady'
});
/**
* Fires when the window has loaded (window.onload)
*/
AXIS.onWindowReady = AXIS.CustomEvent.create({
name: 'onWindowReady'
});
/**
* Fires just prior to the window being unloaded (user leaves or refreshes).
* NOTE: Opera does not support this, and Chrome only seems to fire on refresh.
*/
AXIS.onBeforeUnload = AXIS.CustomEvent.create({
name: 'onBeforeUnload'
});
AXIS.attachEvent('beforeunload',function() {
AXIS.onBeforeUnload.fire();
}, window);
/**
* Fires when the window is resized NOTE how we are
* attaching an event, below.
*/
AXIS.onResize = AXIS.CustomEvent.create({
name: 'onResize'
});
AXIS.attachEvent('resize',function() {
AXIS.onResize.fire();
},window);
/**
* Fires when the window is scrolled. NOTE how we are
* attaching an event, below.
*/
AXIS.onScroll = AXIS.CustomEvent.create({
name: 'onScroll'
});
AXIS.attachEvent('scroll',function() {
AXIS.onScroll.fire();
},window);
/**
* We want to check here if this is minified. When minified, the #_framework
* files are NOT to be loaded. However, the #_framework array is still needed,
* as it will be added to, below, if there are extensions, etc, to load. When
* minified, the #_framework files are added to the top of this file (>cat). We
* don't want to load them again. So we clear the #_framework array if minified.
* The check is for the XHR object; it could be any essential file.
*/
if(typeof XHR == 'function')
{
AXIS._framework = [];
}
var AF = AXIS._framework;
/**
* Load any general CSS
*/
for(var f=0; f < this._generalCSS.length; f++)
{
this.includeCSS({
id: 'css_' + f,
href: this._generalCSS[f]
});
}
/**
* Get any query args first
*/
AXIS.fetchBuildArguments();
/**
* Add the google api loader on request, simply by adding to the framework array.
* Note: need to pass `useGoogleAPI` to AXIS arguments.
*
* @see AXIS#Modules#load
* @see AXIS#User#getUserGeoData
*/
if(AXIS.settings('useGoogleAPI'))
{
// ABQIAAAABH14nUM9IOGSATH59A8PIxTtVJmlcGkc8uAjvGT8FSkFC9SscxRd4KeXJgXC39BF8yapmiOggBEOdg
AF.push('http://www.google.com/jsapi?key=ABQIAAAAL888oCL6bdlp-RuWkSBsthQXxHUepxJBTAuGj9Pcf4C4H-lDUxRnOXsQgDZxtSvcHhv84_sjei_pWQ');
}
/**
* Uses the YUI reset css
*/
if(AXIS.settings('CSSReset'))
{
this.includeCSS({
id: 'CSS_RESET',
href: this.ROOT() + 'css/reset.css'
});
}
/**
* Check if user wants notifications turned off
*/
if(AXIS.settings('disableNotifications'))
{
AXIS._notificationsEnabled = false;
}
var AP = AXIS.PATH();
var lib = AXIS.settings('library');
/**
* Augment framework list with extensions, libraries.
*/
AXIS.buildPathForDirective(AF, AXIS.settings('extensions'));
AXIS.buildPathForDirective(AF, AXIS.settings('libraries'),'libraries');
/**
* When loading an extension `Extension` there is expected to exist a file, `Extension.js`,
* which contains a constructor function named `Extension`. That `Extension` constructor
* is intantiated and attached to the AXIS (via #register) as AXIS.Extension. At which point
* the constructor function `Extension` is "destroyed" by having its value set to null
* (Extension = null). There is a possibility, though unlikely, that the name of a
* constructor function for an extension has already been defined in the DOM prior to
* the AXIS loading process. That is, what if `Extension` had already been defined prior
* to AXIS loading process? In that case we want to store the original value, do our
* business with extensions, and then replace the original value once `Extension` has been
* instantiated. So, prior to doing our object registrations, we store any existing values
* here, and replace them after instantiation (in __build__.js).
*
* @see __build__.js
*/
AXIS.createNamespace('__TVAR');
$AXIS.__TVAR = [];
for(var i=0; i < AF.length; i++)
{
var nm = AF[i].split('/');
nm = nm[nm.length-1].split('.')[0];
$AXIS.__TVAR[nm] = window[nm] || false;
}
var build = function()
{
if((AXIS.minFName == 'AXIS.js') || (AXIS.isIE && AXIS._framework.length))
{
AXIS.includeScript(AP + '__build__.js');
}
else
{
/**
* Begins the startup process for the AXIS. Mainly, registers any extensions that
* were passed as query args, executes anything stored in the AXIS