gitana
Version:
Gitana Cloud CMS Driver for Node JS
1,444 lines (1,226 loc) • 1.05 MB
JavaScript
/*
Gitana JavaScript Driver - Version 1.0.331
Copyright 2019 Gitana Software, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
For more information, please contact Gitana Software, Inc. at this
address:
info@cloudcms.com
*/
/**
* UMD wrapper for compatibility with browser, Node and AMD.
*
* Based on:
* https://github.com/umdjs/umd/blob/master/returnExports.js
*/
(function (root, factory)
{
if (typeof exports === 'object')
{
// Node. Does not work with strict CommonJS, but
// only CommonJS-like environments that support module.exports,
// like Node.
//module.exports = factory(require('b'));
module.exports = factory();
}
else if (typeof define === 'function' && define.amd)
{
// AMD. Register as an anonymous module.
//define(['b'], factory);
define('gitana', [], factory);
}
else
{
// Browser globals
//root.returnExports = factory(root.b);
root["Gitana"] = factory();
}
}(this, function () {
//use b in some fashion.
// Just return a value to define the module export.
// This example returns an object, but the module
// can return a function as the exported value.
//return {};
/**
* This gets added into the Gitana Driver to ensure compilation time compatibility with
* the Appcelerator Titanium framework.
*/
/* jQuery Sizzle - these are to fool the Ti compiler into not reporting errors! */
/**
* The driver assumes a globally-scoped "window" variable which is a legacy of browser-compatibility.
* Frameworks such as Titanium do not have a window root-scoped variable, so we fake one.
*
* At minimum, the window variable must have a setTimeout variable.
*/
if (typeof window === "undefined")
{
window = {
"setTimeout": function(func, milliseconds)
{
setTimeout(func, milliseconds);
}
};
}
/*
Based on Base.js 1.1a (c) 2006-2010, Dean Edwards
Updated to pass JSHint and converted into a module by Kenneth Powers
License: http://www.opensource.org/licenses/mit-license.php
GitHub: https://github.com/KenPowers/Base.js-Module
*/
/*global define:true module:true*/
/*jshint eqeqeq:true*/
(function (name, global, definition) {
// if (typeof module !== 'undefined') {
// module.exports = definition();
// } else if (typeof define !== 'undefined' && typeof define.amd === 'object') {
// define(definition);
// } else {
global[name] = definition();
// }
})('Base', this, function () {
// Base Object
var Base = function () {};
// Implementation
Base.extend = function (_instance, _static) { // subclass
var extend = Base.prototype.extend;
// build the prototype
Base._prototyping = true;
var proto = new this();
extend.call(proto, _instance);
proto.base = function () {
// call this method from any other method to invoke that method's ancestor
};
delete Base._prototyping;
// create the wrapper for the constructor function
//var constructor = proto.constructor.valueOf(); //-dean
var constructor = proto.constructor;
var klass = proto.constructor = function () {
if (!Base._prototyping) {
if (this._constructing || this.constructor === klass) { // instantiation
this._constructing = true;
constructor.apply(this, arguments);
delete this._constructing;
} else if (arguments[0] !== null) { // casting
return (arguments[0].extend || extend).call(arguments[0], proto);
}
}
};
// build the class interface
klass.ancestor = this;
klass.extend = this.extend;
klass.forEach = this.forEach;
klass.implement = this.implement;
klass.prototype = proto;
klass.toString = this.toString;
klass.valueOf = function (type) {
return (type === 'object') ? klass : constructor.valueOf();
};
extend.call(klass, _static);
// class initialization
if (typeof klass.init === 'function') klass.init();
return klass;
};
Base.prototype = {
extend: function (source, value) {
if (arguments.length > 1) { // extending with a name/value pair
var ancestor = this[source];
if (ancestor && (typeof value === 'function') && // overriding a method?
// the valueOf() comparison is to avoid circular references
(!ancestor.valueOf || ancestor.valueOf() !== value.valueOf()) && /\bbase\b/.test(value)) {
// get the underlying method
var method = value.valueOf();
// override
value = function () {
var previous = this.base || Base.prototype.base;
this.base = ancestor;
var returnValue = method.apply(this, arguments);
this.base = previous;
return returnValue;
};
// point to the underlying method
value.valueOf = function (type) {
return (type === 'object') ? value : method;
};
value.toString = Base.toString;
}
this[source] = value;
} else if (source) { // extending with an object literal
var extend = Base.prototype.extend;
// if this object has a customized extend method then use it
if (!Base._prototyping && typeof this !== 'function') {
extend = this.extend || extend;
}
var proto = {
toSource: null
};
// do the "toString" and other methods manually
var hidden = ['constructor', 'toString', 'valueOf'];
// if we are prototyping then include the constructor
for (var i = Base._prototyping ? 0 : 1; i < hidden.length; i++) {
var h = hidden[i];
if (source[h] !== proto[h])
extend.call(this, h, source[h]);
}
// copy each of the source object's properties to this object
for (var key in source) {
if (!proto[key]) extend.call(this, key, source[key]);
}
}
return this;
}
};
// initialize
Base = Base.extend({
constructor: function () {
this.extend(arguments[0]);
}
}, {
ancestor: Object,
version: '1.1',
forEach: function (object, block, context) {
for (var key in object) {
if (this.prototype[key] === undefined) {
block.call(context, object[key], key, object);
}
}
},
implement: function () {
for (var i = 0; i < arguments.length; i++) {
if (typeof arguments[i] === 'function') {
// if it's a function, call it
arguments[i](this.prototype);
} else {
// add the interface using the extend method
this.prototype.extend(arguments[i]);
}
}
return this;
},
toString: function () {
return String(this.valueOf());
}
});
// Return Base implementation
return Base;
});/*
json2.js
2012-10-08
Public Domain.
NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
See http://www.JSON.org/js.html
This code should be minified before deployment.
See http://javascript.crockford.com/jsmin.html
USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
NOT CONTROL.
This file creates a global JSON object containing two methods: stringify
and parse.
JSON.stringify(value, replacer, space)
value any JavaScript value, usually an object or array.
replacer an optional parameter that determines how object
values are stringified for objects. It can be a
function or an array of strings.
space an optional parameter that specifies the indentation
of nested structures. If it is omitted, the text will
be packed without extra whitespace. If it is a number,
it will specify the number of spaces to indent at each
level. If it is a string (such as '\t' or ' '),
it contains the characters used to indent at each level.
This method produces a JSON text from a JavaScript value.
When an object value is found, if the object contains a toJSON
method, its toJSON method will be called and the result will be
stringified. A toJSON method does not serialize: it returns the
value represented by the name/value pair that should be serialized,
or undefined if nothing should be serialized. The toJSON method
will be passed the key associated with the value, and this will be
bound to the value
For example, this would serialize Dates as ISO strings.
Date.prototype.toJSON = function (key) {
function f(n) {
// Format integers to have at least two digits.
return n < 10 ? '0' + n : n;
}
return this.getUTCFullYear() + '-' +
f(this.getUTCMonth() + 1) + '-' +
f(this.getUTCDate()) + 'T' +
f(this.getUTCHours()) + ':' +
f(this.getUTCMinutes()) + ':' +
f(this.getUTCSeconds()) + 'Z';
};
You can provide an optional replacer method. It will be passed the
key and value of each member, with this bound to the containing
object. The value that is returned from your method will be
serialized. If your method returns undefined, then the member will
be excluded from the serialization.
If the replacer parameter is an array of strings, then it will be
used to select the members to be serialized. It filters the results
such that only members with keys listed in the replacer array are
stringified.
Values that do not have JSON representations, such as undefined or
functions, will not be serialized. Such values in objects will be
dropped; in arrays they will be replaced with null. You can use
a replacer function to replace those with JSON values.
JSON.stringify(undefined) returns undefined.
The optional space parameter produces a stringification of the
value that is filled with line breaks and indentation to make it
easier to read.
If the space parameter is a non-empty string, then that string will
be used for indentation. If the space parameter is a number, then
the indentation will be that many spaces.
Example:
text = JSON.stringify(['e', {pluribus: 'unum'}]);
// text is '["e",{"pluribus":"unum"}]'
text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
// text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
text = JSON.stringify([new Date()], function (key, value) {
return this[key] instanceof Date ?
'Date(' + this[key] + ')' : value;
});
// text is '["Date(---current time---)"]'
JSON.parse(text, reviver)
This method parses a JSON text to produce an object or array.
It can throw a SyntaxError exception.
The optional reviver parameter is a function that can filter and
transform the results. It receives each of the keys and values,
and its return value is used instead of the original value.
If it returns what it received, then the structure is not modified.
If it returns undefined then the member is deleted.
Example:
// Parse the text. Values that look like ISO date strings will
// be converted to Date objects.
myData = JSON.parse(text, function (key, value) {
var a;
if (typeof value === 'string') {
a =
/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
if (a) {
return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
+a[5], +a[6]));
}
}
return value;
});
myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
var d;
if (typeof value === 'string' &&
value.slice(0, 5) === 'Date(' &&
value.slice(-1) === ')') {
d = new Date(value.slice(5, -1));
if (d) {
return d;
}
}
return value;
});
This is a reference implementation. You are free to copy, modify, or
redistribute.
*/
/*jslint evil: true, regexp: true */
/*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
lastIndex, length, parse, prototype, push, replace, slice, stringify,
test, toJSON, toString, valueOf
*/
// Create a JSON object only if one does not already exist. We create the
// methods in a closure to avoid creating global variables.
if (typeof JSON !== 'object') {
JSON = {};
}
(function () {
'use strict';
function f(n) {
// Format integers to have at least two digits.
return n < 10 ? '0' + n : n;
}
if (typeof Date.prototype.toJSON !== 'function') {
Date.prototype.toJSON = function (key) {
return isFinite(this.valueOf())
? this.getUTCFullYear() + '-' +
f(this.getUTCMonth() + 1) + '-' +
f(this.getUTCDate()) + 'T' +
f(this.getUTCHours()) + ':' +
f(this.getUTCMinutes()) + ':' +
f(this.getUTCSeconds()) + 'Z'
: null;
};
String.prototype.toJSON =
Number.prototype.toJSON =
Boolean.prototype.toJSON = function (key) {
return this.valueOf();
};
}
var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
gap,
indent,
meta = { // table of character substitutions
'\b': '\\b',
'\t': '\\t',
'\n': '\\n',
'\f': '\\f',
'\r': '\\r',
'"' : '\\"',
'\\': '\\\\'
},
rep;
function quote(string) {
// If the string contains no control characters, no quote characters, and no
// backslash characters, then we can safely slap some quotes around it.
// Otherwise we must also replace the offending characters with safe escape
// sequences.
escapable.lastIndex = 0;
return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
var c = meta[a];
return typeof c === 'string'
? c
: '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
}) + '"' : '"' + string + '"';
}
function str(key, holder) {
// Produce a string from holder[key].
var i, // The loop counter.
k, // The member key.
v, // The member value.
length,
mind = gap,
partial,
value = holder[key];
// If the value has a toJSON method, call it to obtain a replacement value.
if (value && typeof value === 'object' &&
typeof value.toJSON === 'function') {
value = value.toJSON(key);
}
// If we were called with a replacer function, then call the replacer to
// obtain a replacement value.
if (typeof rep === 'function') {
value = rep.call(holder, key, value);
}
// What happens next depends on the value's type.
switch (typeof value) {
case 'string':
return quote(value);
case 'number':
// JSON numbers must be finite. Encode non-finite numbers as null.
return isFinite(value) ? String(value) : 'null';
case 'boolean':
case 'null':
// If the value is a boolean or null, convert it to a string. Note:
// typeof null does not produce 'null'. The case is included here in
// the remote chance that this gets fixed someday.
return String(value);
// If the type is 'object', we might be dealing with an object or an array or
// null.
case 'object':
// Due to a specification blunder in ECMAScript, typeof null is 'object',
// so watch out for that case.
if (!value) {
return 'null';
}
// Make an array to hold the partial results of stringifying this object value.
gap += indent;
partial = [];
// Is the value an array?
if (Object.prototype.toString.apply(value) === '[object Array]') {
// The value is an array. Stringify every element. Use null as a placeholder
// for non-JSON values.
length = value.length;
for (i = 0; i < length; i += 1) {
partial[i] = str(i, value) || 'null';
}
// Join all of the elements together, separated with commas, and wrap them in
// brackets.
v = partial.length === 0
? '[]'
: gap
? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']'
: '[' + partial.join(',') + ']';
gap = mind;
return v;
}
// If the replacer is an array, use it to select the members to be stringified.
if (rep && typeof rep === 'object') {
length = rep.length;
for (i = 0; i < length; i += 1) {
if (typeof rep[i] === 'string') {
k = rep[i];
v = str(k, value);
if (v) {
partial.push(quote(k) + (gap ? ': ' : ':') + v);
}
}
}
} else {
// Otherwise, iterate through all of the keys in the object.
for (k in value) {
if (Object.prototype.hasOwnProperty.call(value, k)) {
v = str(k, value);
if (v) {
partial.push(quote(k) + (gap ? ': ' : ':') + v);
}
}
}
}
// Join all of the member texts together, separated with commas,
// and wrap them in braces.
v = partial.length === 0
? '{}'
: gap
? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}'
: '{' + partial.join(',') + '}';
gap = mind;
return v;
}
}
// If the JSON object does not yet have a stringify method, give it one.
if (typeof JSON.stringify !== 'function') {
JSON.stringify = function (value, replacer, space) {
// The stringify method takes a value and an optional replacer, and an optional
// space parameter, and returns a JSON text. The replacer can be a function
// that can replace values, or an array of strings that will select the keys.
// A default replacer method can be provided. Use of the space parameter can
// produce text that is more easily readable.
var i;
gap = '';
indent = '';
// If the space parameter is a number, make an indent string containing that
// many spaces.
if (typeof space === 'number') {
for (i = 0; i < space; i += 1) {
indent += ' ';
}
// If the space parameter is a string, it will be used as the indent string.
} else if (typeof space === 'string') {
indent = space;
}
// If there is a replacer, it must be a function or an array.
// Otherwise, throw an error.
rep = replacer;
if (replacer && typeof replacer !== 'function' &&
(typeof replacer !== 'object' ||
typeof replacer.length !== 'number')) {
throw new Error('JSON.stringify');
}
// Make a fake root object containing our value under the key of ''.
// Return the result of stringifying the value.
return str('', {'': value});
};
}
// If the JSON object does not yet have a parse method, give it one.
if (typeof JSON.parse !== 'function') {
JSON.parse = function (text, reviver) {
// The parse method takes a text and an optional reviver function, and returns
// a JavaScript value if the text is a valid JSON text.
var j;
function walk(holder, key) {
// The walk method is used to recursively walk the resulting structure so
// that modifications can be made.
var k, v, value = holder[key];
if (value && typeof value === 'object') {
for (k in value) {
if (Object.prototype.hasOwnProperty.call(value, k)) {
v = walk(value, k);
if (v !== undefined) {
value[k] = v;
} else {
delete value[k];
}
}
}
}
return reviver.call(holder, key, value);
}
// Parsing happens in four stages. In the first stage, we replace certain
// Unicode characters with escape sequences. JavaScript handles many characters
// incorrectly, either silently deleting them, or treating them as line endings.
text = String(text);
cx.lastIndex = 0;
if (cx.test(text)) {
text = text.replace(cx, function (a) {
return '\\u' +
('0000' + a.charCodeAt(0).toString(16)).slice(-4);
});
}
// In the second stage, we run the text against regular expressions that look
// for non-JSON patterns. We are especially concerned with '()' and 'new'
// because they can cause invocation, and '=' because it can cause mutation.
// But just to be safe, we want to reject all unexpected forms.
// We split the second stage into 4 regexp operations in order to work around
// crippling inefficiencies in IE's and Safari's regexp engines. First we
// replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
// replace all simple value tokens with ']' characters. Third, we delete all
// open brackets that follow a colon or comma or that begin the text. Finally,
// we look to see that the remaining characters are only whitespace or ']' or
// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
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, ''))) {
// In the third stage we use the eval function to compile the text into a
// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
// in JavaScript: it can begin a block or an object literal. We wrap the text
// in parens to eliminate the ambiguity.
j = eval('(' + text + ')');
// In the optional fourth stage, we recursively walk the new structure, passing
// each name/value pair to a reviver function for possible transformation.
return typeof reviver === 'function'
? walk({'': j}, '')
: j;
}
// If the text is not JSON parseable, then a SyntaxError is thrown.
throw new SyntaxError('JSON.parse');
};
}
}());(function(window)
{
Gitana = Base.extend(
/** @lends Gitana.prototype */
{
/**
* @constructs
*
* @class Gitana
*
* Configuration options should look like:
*
* {
* "clientKey": {String} the oauth2 client id,
* "clientSecret": [String] the oauth2 client secret,
* "baseURL": [String] the relative URI path of the base URL (assumed to be "/proxy"),
* "locale": [String] optional locale (assumed to be en_US),
* "storage": [String|Object] Gitana.OAuth2.Storage implementation or a string identifying where to store
* Gitana OAuth2 tokens ("local", "session", "memory") or empty for memory-only storage
* }
*/
constructor: function(settings)
{
var self = this;
if (!settings)
{
settings = {};
}
if (settings.host)
{
settings.baseURL = settings.host + "/proxy";
}
this.applicationInfo = {};
this.stackInfo = {};
// build config
var config = {
"clientKey": null,
"clientSecret": null,
"baseURL": "/proxy",
"locale": (Gitana.DEFAULT_LOCALE ? Gitana.DEFAULT_LOCALE : null),
"application": null,
"loadAppHelper": true,
"storage": null
};
if (Gitana.DEFAULT_CONFIG)
{
for (var k in Gitana.DEFAULT_CONFIG)
{
if (Gitana.DEFAULT_CONFIG.hasOwnProperty(k))
{
config[k] = Gitana.DEFAULT_CONFIG[k];
}
}
}
Gitana.copyKeepers(config, Gitana.loadDefaultConfig());
Gitana.copyKeepers(config, settings);
if (typeof(config.cacheBuster) === "undefined")
{
config.cacheBuster = true;
}
//////////////////////////////////////////////////////////////////////////
//
// APPLY CONFIGURATION SETTINGS
//
// baseURL
this.baseURL = config.baseURL;
// locale
this.locale = config.locale;
//////////////////////////////////////////////////////////////////////////
//
// APPLY OAUTH2 SETTINGS
//
// set up our oAuth2 connection
var options = {};
if (config.clientKey) {
options.clientKey = config.clientKey;
}
if (config.clientSecret) {
options.clientSecret = config.clientSecret;
}
if (this.baseURL)
{
options.baseURL = this.baseURL;
options.tokenURL = "/oauth/token";
}
// the driver requires the "api" scope to be granted
options.requestedScope = "api";
//////////////////////////////////////////////////////////////////////////
//
// PRIVILEGED METHODS
//
//
this.updateOptions = function(o)
{
if (o)
{
Gitana.copyInto(options, o);
}
};
this.resetHttp = function(config)
{
var o = {};
Gitana.copyInto(o, options);
if (config)
{
Gitana.copyInto(o, config);
}
if (!o.storage)
{
o.storage = this.getOriginalConfiguration().storage;
}
self.http = new Gitana.OAuth2Http(o, o.storage);
};
this.setAuthInfo = function(authInfo)
{
this.authInfo = authInfo;
};
this.setStackInfo = function(stackInfo)
{
this.stackInfo = stackInfo;
};
this.setApplicationInfo = function(applicationInfo)
{
this.applicationInfo = applicationInfo;
};
this.getOriginalConfiguration = function()
{
return config;
};
this.getHttpHeaders = function()
{
var self = this;
var headers = {};
if (self.http && self.http.getBearerAuthorizationHeader())
{
headers["Authorization"] = self.http.getBearerAuthorizationHeader();
}
return headers;
};
},
/**
* Sets the authentication info
*/
getAuthInfo: function()
{
return this.authInfo;
},
getStackInfo: function()
{
return this.stackInfo;
},
getApplicationInfo: function()
{
return this.applicationInfo;
},
/**
* Sets the default locale for interactions with the Gitana server by this driver.
*
* @public
*
* @param {String} locale locale string
*/
setLocale: function(locale)
{
this.locale = locale;
},
/**
* Retrieves the default locale being used by this driver.
*
* @returns {String} locale string
*/
getLocale: function()
{
return this.locale;
},
/**
* Default AJAX failure callback
*
* @public
*/
defaultFailureCallback: function(http)
{
// if we're in debug mode, log a bunch of good stuff out to console
if (this.debug)
{
if (typeof console != "undefined")
{
var message = "Received bad http state (" + http.status + ")";
var stacktrace = null;
var json = null;
var responseText = http.responseText;
if (responseText)
{
json = JSON.parse(responseText);
if (json && json.message)
{
message = message + ": " + json.message;
}
}
if (json && json["stacktrace"])
{
stacktrace = json["stacktrace"];
}
console.log(message);
if (stacktrace)
{
console.log(stacktrace);
}
}
}
},
/**
* Performs Ajax communication with the Gitana server.
*
* NOTE: For the most part, you shouldn't have to use this function since most of the things you'd want
* to do with the Gitana server are wrapped by helper functions.
*
* @see Gitana.Driver#gitanaGet
* @see Gitana.Driver#gitanaPost
* @see Gitana.Driver#gitanaPut
* @see Gitana.Driver#gitanaDel
* @see Gitana.Driver#gitanaRequest
*
* @public
*
* @param {String} method The kind of method to invoke - "get", "post", "put", or "del"
* @param {String} url The full URL to the resource being requested (i.e. "http://server:port/uri"}
* @param {String} [contentType] In the case of a payload carrying request (i.e. not GET), the content type being sent.
* @param {Object} [data] In the case of a payload carrying request (i.e. not GET), the data to plug into the payload.
* @param {Object} [headers] A key/value map of headers to place into the request.
* @param {Function} [successCallback] The function to call if the operation succeeds.
* @param {Function} [failureCallback] The function to call if the operation fails. If none provided, the default driver callback is used.
*/
ajax: function(method, url, contentType, data, headers, successCallback, failureCallback)
{
var _this = this;
// ensure headers
if (!headers)
{
headers = {};
}
// treat the method
if (method == null) {
method = "GET";
}
method = method.toUpperCase();
// flags
var json = false;
if (contentType == "application/json")
{
json = true;
}
// error checking
if ( (method === "POST" || method === "PUT") )
{
headers["Content-Type"] = contentType;
if (!contentType)
{
Gitana.debug("Performing method: " + method + " but missing content type");
return;
}
}
var toSend = data;
// special handling for json
if (json)
{
// if empty payload for payload-bearing methods, populate with {}
if (method === "PUT" || method === "POST")
{
if (!data)
{
data = {};
}
}
if (!Gitana.isString(data))
{
// stringify
toSend = Gitana.stringify(data);
}
}
//
// if the URL is relative and we're running in a browser, then we can pad the URL
// based on the URL of the browser
//
// otherwise, we can't handle relative URLs
//
if (url.substring(0,1) === "/")
{
// if window.location exists, then we're running on a browser
if (!Gitana.isUndefined(window.location))
{
var u = window.location.protocol + "//" + window.location.host;
if (window.location.host.indexOf(":") === -1)
{
if (window.location.port) {
u += ":" + window.location.port;
}
}
url = u + url;
}
else
{
// relative urls are not supported outside of the browser
throw new Error("Relative URL not supported outside of the browser: " + url);
}
}
var config = {
"method": method,
"url": url,
"data": toSend,
"headers": headers,
"success": successCallback,
"failure": failureCallback
};
Gitana.requestCount++;
this.http.request(config);
return this;
},
/**
* Send an HTTP request via AJAX to the Gitana Server.
*
* This method will additionally make sure of the following:
*
* 1) That the Gitana Driver authentication ticket is plugged onto the request.
* 2) That the Gitana Driver locale is plugged onto the request.
* 3) That full object data is returned (including metadata).
*
* @public
*
* @param {String} method The kind of method to invoke - "get", "post", "put", or "del"
* @param {String} url Either a full URL (i.e. "http://server:port/uri") or a URI against the driver's server URL (i.e. /repositories/...)
* @param {Object} params parameter map
* @param [String] contentType If the case of a payload carrying request (i.e. not GET), the content type being sent.
* @param {Object} data In the case of a payload carrying request (i.e. not GET), the JSON to plug into the payload.
* @param {Function} [successCallback] The function to call if the operation succeeds.
* @param {Function} [failureCallback] The function to call if the operation fails.
*/
gitanaRequest: function(method, url, params, contentType, data, headers, successCallback, failureCallback)
{
// ensure we have some params
if (!params)
{
params = {};
}
// if url has query string params, move into params
// strip back url so that it does not have query params
var x1 = url.indexOf("?");
if (x1 > -1)
{
var qs = url.substring(x1 + 1);
url = url.substring(0, x1);
var parts = qs.split("&");
for (var x2 = 0; x2 < parts.length; x2++)
{
var keyValuePair = parts[x2].split("=");
params[keyValuePair[0]] = keyValuePair[1];
}
}
// make sure we compute the real url
if (Gitana.startsWith(url, "/")) {
url = this.baseURL + url;
}
if (!failureCallback)
{
failureCallback = this.defaultFailureCallback;
}
if (!headers)
{
headers = {};
}
/**
* Primary success callback handler for oAuth call to server.
*
* @param responseObject
* @param xhr
*/
var onSuccess = function(responseObject, xhr)
{
if (successCallback)
{
// call back with just the response text (or json)
var arg = responseObject.text;
if (contentType === "application/json")
{
try {
arg = new Gitana.Response(JSON.parse(arg));
} catch (ex) {
failureCallback(ex);
}
}
successCallback(arg);
}
};
/**
* Primary failure callback handler for oAuth call to server.
*
* @param responseObject
* @param xhr
*/
var onFailure = function(responseObject, xhr)
{
if (failureCallback)
{
var httpError = {};
if (responseObject && responseObject.timeout)
{
// due to a timeout
httpError["statusText"] = "Connection timed out";
httpError["status"] = xhr.status;
httpError["errorType"] = "timeout";
httpError["message"] = "Connection timed out";
httpError["xhr"] = xhr;
httpError["response"] = responseObject;
if (responseObject.info)
{
httpError["info"] = responseObject.info;
}
}
else
{
// due to an HTTP error
httpError["statusText"] = xhr.statusText;
httpError["status"] = xhr.status;
httpError["errorType"] = "http";
httpError["xhr"] = xhr;
if (responseObject)
{
httpError["response"] = responseObject;
}
var message = null;
var stacktrace = null;
if (contentType === "application/json")
{
try
{
var arg = responseObject.text;
var obj = new Gitana.Response(JSON.parse(arg));
if (obj.message)
{
message = obj.message;
}
if (obj.stacktrace)
{
stacktrace = obj.stacktrace;
}
}
catch (e) { }
}
if (message)
{
httpError.message = message;
}
if (stacktrace)
{
httpError.stacktrace = stacktrace;
}
}
failureCallback(httpError);
}
};
// copy in globally defined params
if (Gitana.HTTP_PARAMS)
{
for (var k in Gitana.HTTP_PARAMS)
{
if (Gitana.HTTP_PARAMS.hasOwnProperty(k))
{
params[k] = Gitana.HTTP_PARAMS[k];
}
}
}
// copy in globally defined headers
if (Gitana.HTTP_HEADERS)
{
for (var k in Gitana.HTTP_HEADERS)
{
if (Gitana.HTTP_HEADERS.hasOwnProperty(k))
{
headers[k] = Gitana.HTTP_HEADERS[k];
}
}
}
// adjust url to include "full" as well as "metadata" if not included
if (Gitana.isEmpty(params["metadata"]))
{
params["metadata"] = true;
}
if (Gitana.isEmpty(params["full"]))
{
params["full"] = true;
}
// set the locale
if (this.locale === null)
{
if (!params["locale"])
{
params["locale"] = "default";
}
}
else if (typeof(this.locale) !== "undefined")
{
headers["accept-language"] = this.locale;
params["locale"] = this.locale;
}
// cache buster
var cacheBuster = null;
if (this.getOriginalConfiguration().cacheBuster === true)
{
cacheBuster = new Date().getTime();
}
else if (typeof(this.getOriginalConfiguration().cacheBuster) === "string")
{
cacheBuster = this.getOriginalConfiguration().cacheBuster;
}
else if (typeof(this.getOriginalConfiguration().cacheBuster) === "function")
{
cacheBuster = this.getOriginalConfiguration().cacheBuster();
}
if (cacheBuster)
{
params["cb"] = cacheBuster;
}
// update URL to include params
for (var paramKey in params)
{
var paramValue = params[paramKey];
if (Gitana.isFunction(paramValue))
{
paramValue = paramValue.call();
}
else if (Gitana.isString(paramValue))
{
// make sure all param strings are escaped
paramValue = Gitana.escape(paramValue);
}
else if (Gitana.isNumber(paramValue))
{
// NOTHING TO DO
}
else
{
paramValue = Gitana.escape(Gitana.stringify(paramValue, false));
}
// apply
if (url.indexOf("?") > -1)
{
url = url + "&" + paramKey + "=" + paramValue;
}
else
{
url = url + "?" + paramKey + "=" + paramValue;
}
}
return this.ajax(method, url, contentType, data, headers, onSuccess, onFailure);
},
/**
* Sends an HTTP GET request to the Gitana server.
*
* @public
*
* @param {String} url Either a full URL (i.e. "http://server:port/uri") or a URI against the driver's server URL (i.e. /repositories/...)
* @param {Object} params request parameters
* @param {Object} headers request headers
* @param {Function} [successCallback] The function to call if the operation succeeds.
* @param {Function} [failureCallback] The function to call if the operation fails.
*/
gitanaGet: function(url, params, headers, successCallback, failureCallback)
{
return this.gitanaRequest("GET", url, params, "application/json", null, headers, successCallback, failureCallback);
},
/**
* Sends an HTTP GET request to the Gitana server.
*
* @public
*
* @param {String} url Either a full URL (i.e. "http://server:port/uri") or a URI against the driver's server URL (i.e. /repositories/...)
* @param {Object} params request parameters
* @param {Function} [successCallback] The function to call if the operation succeeds.
* @param {Function} [failureCallback] The function to call if the operation fails.
*/
gitanaDownload: function(url, params, successCallback, failureCallback)
{
return this.gitanaRequest("GET", url, params, null, null, {}, successCallback, failureCallback);
},
/**
* Sends an HTTP POST request to the Gitana server.
*
* @public
*
* @param {String} url Either a full URL (i.e. "http://server:port/uri") or a URI against the driver's server URL (i.e. /repositories/...)
* @param {Object} params request parameters
* @param {Object} [jsonData] The JSON to plug into the payload.
* @param {Function} [successCallback] The function to call if the operation succeeds.
* @param {Function} [failureCallback] The function to call if the operation fails.
*/
gitanaPost: function(url, params, jsonData, successCallback, failureCallback)
{
return this.gitanaRequest("POST", url, params, "application/json", jsonData, {}, successCallback, failureCallback);
},
/**
* Sends an HTTP POST request to the Gitana server.
*
* @public
*
* @param {String} url Either a full URL (i.e. "http://server:port/uri") or a URI against the driver's server URL (i.e. /repositories/...)
* @param {Object} params request parameters
* @param {String} contentType content type being sent
* @param {Object} [jsonData] The JSON to plug into the payload.
* @param {Function} [successCallback] The function to call if the operation succeeds.
* @param {Function} [failureCallback] The function to call if the operation fails.
*/
gitanaUpload: function(url, params, contentType, data, successCallback, failureCallback)
{
return this.gitanaRequest("POST", url, params, contentType, data, {}, successCallback, failureCallback);
},
/**
* Sends an HTTP PUT request to the Gitana server.
*
* @public
*
* @param {String} url Either a full URL (i.e. "http://server:port/uri") or a URI against the driver's server URL (i.e. /repositories/...)
* @param {Object} params request parameters
* @param {Object} [jsonData] The JSON to plug into the payload.
* @param {Function} [successCallback] The function to call if the operation succeeds.
* @param {Function} [failureCallback] The function to call if the operation fails.
*/
gitanaPut: function(url, params, jsonData, successCallback, failureCallback)
{
return this.gitanaRequest("PUT", url, params, "application/json", jsonData, {}, successCallback, failureCallback);
},
/**
* Sends an HTTP PATCH request to the Gitana server.
*
* @public
*
* @param {String} url Either a full URL (i.e. "http://server:port/uri") or a URI against the driver's server URL (i.e. /repositories/...)
* @param {Object} params request parameters
* @param {Object} [jsonData] The JSON to plug into the payload.
* @param {Function} [successCallback] The function to call if the operation succeeds.
* @param {Function} [failureCallback] The function to call if the operation fails.
*/
gitanaPatch: function(url, params, jsonData, successCallback, failureCallback)
{
return this.gitanaRequest("PATCH", url, params, "application/json", jsonData, {}, successCallback, failureCallback);
},
/**
* Sends an HTTP DELETE request to the