/ajax/libs/angularSubkit/1.0.2/angularsubkit.js

//  - 1.0.2
// https://github.com/subkit
// Copyright 2012 - 2015 http://subkit.io
// MIT License

!function(e){"object"==typeof exports?module.exports=e():"function"==typeof define&&define.amd?define(e):"undefined"!=typeof window?window.Subkit=e():"undefined"!=typeof global?global.Subkit=e():"undefined"!=typeof self&&(self.Subkit=e())}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
module.exports = function(subkit, subscriptions, poll){
	'use strict';
	
	return function(){
		
		return {
			list: function(callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/events/streams';
				subkit.httpRequest.get(url, subkit.options, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200) deferred.reject(new Error(result.json().message));
					else deferred.resolve(result.json());
				});
				return deferred.promise.nodeify(callback);
			},
			log: function(stream, callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/events/log/' + stream;

				subkit.httpRequest.get(url, subkit.options, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200) deferred.reject(new Error(result.json().message));
					else deferred.resolve(result.json());
				});
				return deferred.promise.nodeify(callback);
			},
			remove: function(stream, callback){
                var deferred = subkit.$q.defer();
                var url = subkit.baseUrl + '/events/log/' + stream;
				subkit.httpRequest.del(url, subkit.options, function(status, result){
                    if (status === 0) deferred.reject(new Error('No network connection.'));
                    else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
                    else deferred.resolve(result.json());
				});
                return deferred.promise.nodeify(callback);
			},
			emit: function(stream, payload, persistent, metadata, callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/events/emit/' + stream;
				var msg = JSON.parse(JSON.stringify(subkit.options));
				msg.data = payload;
				if(persistent) msg.headers['X-Subkit-Event-Persistent'] = true;
				if(metadata) msg.headers['X-Subkit-Event-Metadata'] = JSON.stringify(metadata);

				subkit.httpRequest.post(url, msg, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200 && status !== 201 && status !== 202) deferred.reject(new Error(result.json().message));
					else deferred.resolve(result.json());
				});
				return deferred.promise.nodeify(callback);
			},
			on: function(stream, callback) {
				stream = stream.replace('/', '_');
				subscriptions[stream] = poll(stream, callback);
				return {
					off: function(){
						delete subscriptions[stream];
						if(subscriptions[stream]) subscriptions[stream]().abort();
					},
					emit: function(value, callback){
						subkit.events.emit(stream, value, callback);
					}
				};
			},
			off: function(stream){
				if(subscriptions[stream]) subscriptions[stream]().abort();
				delete subscriptions[stream];
                return false;	
			}
		};

	};
};
},{}],2:[function(require,module,exports){
module.exports = function(subkit){
	'use strict';
	
	return function(){

		return {
			login: function(callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/manage/login';
				subkit.httpRequest.authBasic(subkit.options.username, subkit.options.password);
				subkit.httpRequest.post(url, subkit.options, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200) deferred.reject(new Error(result.json().message));
					else {
						subkit.options.apiKey = result.json().api.apiKey;
						deferred.resolve({
							apiKey: subkit.options.apiKey,
							username: subkit.options.username,
							password: subkit.options.password,
							baseUrl: subkit.baseUrl
						});
					}
				});
				return deferred.promise.nodeify(callback);
			},		
			import: function(file, callback){
				var deferred = subkit.$q.defer();
				var msg = JSON.parse(JSON.stringify(subkit.options));
				msg.headers = {
				  'Content-Type': 'application/octed-stream'
				};
				msg.data = file;
				var url = subkit.baseUrl + '/manage/import';
				subkit.httpRequest.post(url, msg, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 201) deferred.reject(new Error(result.json().message));
					else deferred.resolve(result.json());
				});
				return deferred.promise.nodeify(callback);
			},
			export: function(callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/manage/export';
				subkit.httpRequest.get(url, subkit.options, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200) deferred.reject(new Error(result.json().message));
					else deferred.resolve('data:application/octet-stream,' + result.text());
				});
				return deferred.promise.nodeify(callback);
			},
			backup: function(callback){
				if(callback) callback();
			},
			restore: function(name, callback){
				if(callback) callback();
			},
			password: {
				set: function(oldPassword, newPassword, verifyPassword, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/password/action/reset';
					var msg = JSON.parse(JSON.stringify(subkit.options));
					msg.data = {
						password: oldPassword,
						newPassword: newPassword,
						newPasswordValidation: verifyPassword
					};
					subkit.httpRequest.put(url, msg, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				}
			},
			user: {
				set: function(username, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/user';
					var msg = JSON.parse(JSON.stringify(subkit.options));
					msg.data = {
						username: username
					};
					subkit.httpRequest.put(url, msg, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				}
			},
			apikey: {
				reset: function(callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/apikey/action/reset';
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				}
			},
			certificate:{
				get: function(callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/certificate';
					subkit.httpRequest.get(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				set: function(certificate, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/certificate/action/change';
					var msg = JSON.parse(JSON.stringify(subkit.options));
					msg.data = certificate;
					subkit.httpRequest.put(url, msg, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 201 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				}
			},
			status: {
				get: function(callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/os';
					subkit.httpRequest.get(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				kill: function(callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/kill';
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				}				
			},
			plugins: {
				list: function(callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/plugins';
					subkit.httpRequest.get(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				install: function(name,callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/plugins/' + name;
					subkit.httpRequest.post(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 201 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				update: function(name,callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/plugins/' + name;
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},				
				uninstall: function(name,callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/plugins/' + name;
					subkit.httpRequest.del(url, subkit.options, function(status, result){
	                    if (status === 0) deferred.reject(new Error('No network connection.'));
	                    else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
	                    else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				}			 
			},
			permissions:{
				roles: function(callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/identities';
					subkit.httpRequest.get(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				list: function(identity, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/' + identity;
					subkit.httpRequest.get(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				set: function(key, callback){
					var deferred = subkit.$q.defer();				
					var url = subkit.baseUrl + '/manage/permissions/' + encodeURIComponent(key);
					subkit.httpRequest.post(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 201 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				remove: function(key, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/' + encodeURIComponent(key);
					subkit.httpRequest.del(url, subkit.options, function(status, result){
	                    if (status === 0) deferred.reject(new Error('No network connection.'));
	                    else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
	                    else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				grantInsert: function(key, identity, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/' + encodeURIComponent(key) + '/action/grantinsert/' + identity;
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				grantUpdate: function(key, identity, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/' + encodeURIComponent(key) + '/action/grantupdate/' + identity;
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},			
				grantDelete: function(key, identity, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/' + encodeURIComponent(key) + '/action/grantdelete/' + identity;
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				grantRead: function(key, identity, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/' + encodeURIComponent(key) + '/action/grantread/' + identity;
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				revokeInsert: function(key, identity, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/' + encodeURIComponent(key) + '/action/revokeinsert/' + identity;
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				revokeUpdate: function(key, identity, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/' + encodeURIComponent(key) + '/action/revokeupdate/' + identity;
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},			
				revokeDelete: function(key, identity, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/' + encodeURIComponent(key) + '/action/revokedelete/' + identity;
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				},
				revokeRead: function(key, identity, callback){
					var deferred = subkit.$q.defer();
					var url = subkit.baseUrl + '/manage/permissions/' + encodeURIComponent(key) + '/action/revokeread/' + identity;
					subkit.httpRequest.put(url, subkit.options, function(status, result){
						if (status === 0) deferred.reject(new Error('No network connection.'));
						else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
						else deferred.resolve(result.json());
					});
					return deferred.promise.nodeify(callback);
				}
			}	
		};
	};
};
},{}],3:[function(require,module,exports){
module.exports = function(subkit, subscriptions, poll){
	'use strict';
	
	return function(store){
		var _prepareUrl = function(key){
			if(store && !key) return subkit.baseUrl + '/stores/' + store;
			if(store && key) return subkit.baseUrl + '/stores/' + store + '/' + key;
			if(!store && key && key.indexOf('!') !== -1) {
				key = key.replace(/^[a-zA-z0-9]\/\//, '!');
				return subkit.baseUrl + '/stores/' + key;
			}
			if(!store && key) return subkit.baseUrl + '/stores/' + key;
			return subkit.baseUrl + '/stores';
		};
		var _prepareParams = function(url, params){
			var queryString = '';
			for(var key in params){
				if(key === 'where') {
					var jsonFilter = JSON.stringify(params[key]);
					queryString += '&where=' + jsonFilter;
				} else {
					queryString += '&' + key + '=' + params[key];
				}
			}
			queryString = queryString.substring(1, queryString.length);
			return url + '?' + queryString;
		};

		var ref = {
			key: function(){
				return Subkit.UUID();
			},
			import: function(file, callback){
				var deferred = subkit.$q.defer();
				var msg = JSON.parse(JSON.stringify(subkit.options));
				msg.headers = {
					'Content-Type': 'application/octed-stream',
					apiKey: config.apiKey
				};
				msg.data = file;
				var url = subkit.baseUrl + '/manage/import/' + store;
				subkit.httpRequest.post(url, msg, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
                    else if (status !== 200 && status!==201 && status!==202) deferred.reject(new Error(result.json().message));
                    else deferred.resolve(result.json());
				});
				return deferred.promise.nodeify(callback);
			},
			export: function(callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/manage/export/' + store;
				subkit.httpRequest.get(url, subkit.options, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
                    else if (status !== 200) deferred.reject(new Error(result.json().message));
                    else deferred.resolve('data:application/octet-stream,' + result.text());
				});
				return deferred.promise.nodeify(callback);
			},
			add: function(key, value, callback){
				var deferred = subkit.$q.defer();
				key = arguments[0];
				value = arguments[1];

				if(arguments.length === 1 && key instanceof Object){
					value = key;
					key = Subkit.UUID();
				}
				var url = _prepareUrl(key);
				var msg = JSON.parse(JSON.stringify(subkit.options));
				msg.data = value;
				
				subkit.httpRequest.post(url, msg, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
                    else if (status!==201) deferred.reject(new Error(result.json().message));
                    else deferred.resolve(result.json());
				});
				
				return deferred.promise.nodeify(callback);
			},			
			set: function(key, value, version, callback){
				if(typeof version === 'function') {
					callback = version;
					version = undefined;
				}

				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/stores/' + store + '/' + key;
				var msg = JSON.parse(JSON.stringify(subkit.options));
				msg.data = value;
				if(version) msg.headers['If-Match'] = version;	

				subkit.httpRequest.put(url, msg, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
                    else if (status !== 200 && status!==202) deferred.reject(new Error(result.json().message));
                    else deferred.resolve(result.json());
				});
				
				return deferred.promise.nodeify(callback);
			},			
			get: function(key, callback){
                var deferred = subkit.$q.defer();
				subkit.httpRequest.get(_prepareUrl(key), subkit.options, function(status, result){
                    if (status === 0) deferred.reject(new Error('No network connection.'));
                    else if (status !== 200) deferred.reject(new Error(result.json().message));
                    else deferred.resolve(result.json());
				});
                return deferred.promise.nodeify(callback);
			},
			find: function(query, callback){
				var url = _prepareUrl(query.key);
				url = _prepareParams(url, query);
                var deferred = subkit.$q.defer();
				subkit.httpRequest.get(url, subkit.options, function(status, result){
                    if (status === 0) deferred.reject(new Error('No network connection.'));
                    else if (status !== 200) deferred.reject(new Error(result.json().message));
                    else deferred.resolve(result.json());
				});
                return deferred.promise.nodeify(callback);
			},
			remove: function(key, version, callback){
				if(typeof version === 'function') {
					callback = version;
					version = undefined;
				}
				
                var deferred = subkit.$q.defer();
				var msg = JSON.parse(JSON.stringify(subkit.options));
                if(version) msg.headers['If-Match'] = version;

				subkit.httpRequest.del(_prepareUrl(key), msg, function(status, result){
                    if (status === 0) deferred.reject(new Error('No network connection.'));
                    else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
                    else deferred.resolve(result.json());
				});
                return deferred.promise.nodeify(callback);
			},
			log: function(callback){
                var deferred = subkit.$q.defer();
				subkit.httpRequest.get('', subkit.options, function(status, result){
                    if (status === 0) deferred.reject(new Error('No network connection.'));
                    else if (status !== 200) deferred.reject(new Error(result.json().message));
                    else deferred.resolve(result.json());
				});
                return deferred.promise.nodeify(callback);
			},
			on: function(callback){
				if(subscriptions[store]) subscriptions[store]().abort();
				subscriptions[store] = poll(store, callback);
                return true;	
			},
			off: function(){
				if(subscriptions[store]) subscriptions[store]().abort();
				delete subscriptions[store];
                return false;	
			}
		};
		return ref;
	};

};
},{}],4:[function(require,module,exports){
module.exports = function(subkit){
	'use strict';
	
	return function(){
		
		return {
			set: function(task, callback){
				var deferred = subkit.$q.defer();
				var msg = JSON.parse(JSON.stringify(subkit.options));
				msg.data = task;
				var url = subkit.baseUrl + '/tasks/' + task.name;
				subkit.httpRequest.put(url, msg, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200 && status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
					else deferred.resolve(result.json());
				});
				return deferred.promise.nodeify(callback);
			},	
			get: function(taskName, callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/tasks/' + taskName;
				subkit.httpRequest.get(url, subkit.options, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200) deferred.reject(new Error(result.json().message));
					else deferred.resolve(result.json());
				});
				return deferred.promise.nodeify(callback);
			},
			remove: function(taskName, callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/tasks/' + taskName;
				subkit.httpRequest.del(url, subkit.options, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
					else deferred.resolve(result.json());
				});
				return deferred.promise.nodeify(callback);
			},
			list: function(callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/tasks';
				subkit.httpRequest.get(url, subkit.options, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200) deferred.reject(new Error(result.json().message));
					else deferred.resolve(result.json());
				});
				return deferred.promise.nodeify(callback);
			},
			runDebug: function(taskName, value, callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/tasks/api/' + taskName;
				var msg = JSON.parse(JSON.stringify(subkit.options));
				msg.data = value;
				subkit.httpRequest.get(url, msg, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200) deferred.reject(new Error(result.json().message));
					else deferred.resolve({
						result: result.json(),
	                    raw: result.text(),
						headers: result.headers(),
	                    log: result.log()  
					});
				});
				return deferred.promise.nodeify(callback);
			},		
			run: function(taskName, value, callback){
				var deferred = subkit.$q.defer();
				var url = subkit.baseUrl + '/tasks/action/run/' + taskName;
				var msg = JSON.parse(JSON.stringify(subkit.options));
				msg.data = value;
				subkit.httpRequest.get(url, msg, function(status, result){
					if (status === 0) deferred.reject(new Error('No network connection.'));
					else if (status !== 200) deferred.reject(new Error(result.json().message));
					else deferred.resolve(result.json());
				});
				return deferred.promise.nodeify(callback);
			}	
		};
	};
};
},{}],5:[function(require,module,exports){
/** @module Subkit */

/**
* Subkit
* @param {object} config - A Subkit configuration
*/
var Subkit = function (config){
	'use strict';
	
	var self = this;
	var subscriptions = {};

	self.clientId = config.clientId || initClientId();
	self.baseUrl = config.baseUrl || ((window.location.origin.indexOf('http') !== -1) ? window.location.origin : 'https://localhost:8080');
    self.options = { 
    	apiKey: config.apiKey || '',
    	username: config.username || '',
    	password: config.password || '',
    	headers : {
    		'Content-Type': 'application/json'
    	}
    };	
	self.httpRequest = {
		authBasic: function (username, password) {
		  self.httpRequest.headers({});
		  ajax.headers['Authorization'] = 'Basic ' + base64(username + ':' + password);
		},
		connect: function (url, options, callback) {
		  return ajax('CONNECT', url, options, callback);      
		},
		del: function (url, options, callback) {
		  return ajax('DELETE', url, options, callback);      
		},
		get: function (url, options, callback) {
		  return ajax('GET', url, options, callback);
		},
		head: function (url, options, callback) {
		  return ajax('HEAD', url, options, callback);
		},
		headers: function (headers) {
		  ajax.headers = headers || {};
		},
		isAllowed: function (url, verb, callback) {
		  this.options(url, function (status, data) {
		    callback(data.text().indexOf(verb) !== -1);
		  });
		},
		options: function (url, options, callback) {
		  return ajax('OPTIONS', url, options, callback);
		},
		patch: function (url, options, callback) {
		  return ajax('PATCH', url, options, callback);      
		},
		post: function (url, options, callback) {
		  return ajax('POST', url, options, callback);      
		},
		put: function (url, options, callback) {
		  return ajax('PUT', url, options, callback);      
		},
		trace: function (url, options, callback) {
		  return ajax('TRACE', url, options, callback);
		}
	};

	self.$q = require('q');
	self.manage = require('./lib/manage')(self);
	self.tasks = require('./lib/tasks')(self);
	self.stores = require('./lib/stores')(self, subscriptions, poll);
	self.events = require('./lib/events')(self, subscriptions, poll);

	function getXhr(callback) {
		if (window.XMLHttpRequest) {
		  return callback(null, new XMLHttpRequest());
		} else if (window.ActiveXObject) {
		  try {
		    return callback(null, new ActiveXObject('Msxml2.XMLHTTP'));
		  } catch (e) {
		    return callback(null, new ActiveXObject('Microsoft.XMLHTTP'));
		  }
		}
		return callback(new Error());
	}
	function encodeUsingUrlEncoding(data) {
		if(typeof data === 'string') {
		  return data;
		}

		var result = [];
		for(var dataItem in data) {
		  if(data.hasOwnProperty(dataItem)) {
		    result.push(encodeURIComponent(dataItem) + '=' + encodeURIComponent(data[dataItem]));
		  }
		}

		return result.join('&');
	}
	function utf8(text) {
		text = text.replace(/\r\n/g, '\n');
		var result = '';

		for(var i = 0; i < text.length; i++) {
		  var c = text.charCodeAt(i);

		  if(c < 128) {
		      result += String.fromCharCode(c);
		  } else if((c > 127) && (c < 2048)) {
		      result += String.fromCharCode((c >> 6) | 192);
		      result += String.fromCharCode((c & 63) | 128);
		  } else {
		      result += String.fromCharCode((c >> 12) | 224);
		      result += String.fromCharCode(((c >> 6) & 63) | 128);
		      result += String.fromCharCode((c & 63) | 128);
		  }
		}

		return result;
	}
	function base64(text) {
		var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';

		text = utf8(text);
		var result = '',
		    chr1, chr2, chr3,
		    enc1, enc2, enc3, enc4,
		    i = 0;

		do {
		  chr1 = text.charCodeAt(i++);
		  chr2 = text.charCodeAt(i++);
		  chr3 = text.charCodeAt(i++);

		  enc1 = chr1 >> 2;
		  enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
		  enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
		  enc4 = chr3 & 63;

		  if(isNaN(chr2)) {
		    enc3 = enc4 = 64;
		  } else if(isNaN(chr3)) {
		    enc4 = 64;
		  }

		  result +=
		    keyStr.charAt(enc1) +
		    keyStr.charAt(enc2) +
		    keyStr.charAt(enc3) +
		    keyStr.charAt(enc4);
		  chr1 = chr2 = chr3 = '';
		  enc1 = enc2 = enc3 = enc4 = '';
		} while(i < text.length);

		return result;
	}
	function mergeHeaders() {
		var result = arguments[0];
		for(var i = 1; i < arguments.length; i++) {
		  var currentHeaders = arguments[i];
		  for(var header in currentHeaders) {
		    if(currentHeaders.hasOwnProperty(header)) {
		      result[header] = currentHeaders[header];
		    }
		  }
		}
		return result;
	}
	function ajax(method, url, options, callback) {
		if(typeof options === 'function') {
		  callback = options;
		  options = {};
		}
		options.cache = options.cache || true;
		options.headers = options.headers || {};
		options.jsonp = options.jsonp || false;

		var headers = mergeHeaders({
		  'Accept': '*/*',
		  'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
		  'X-Auth-Token': options.apiKey
		}, ajax.headers, options.headers);

		var payload;
		
		if(options.data) {
			if ((method === 'GET') && (headers['Content-Type'] === 'application/json')) {
			  	payload = encodeUsingUrlEncoding(options.data);
			} 
			else if (headers['Content-Type'] === 'application/json') {
				payload = JSON.stringify(options.data);
			} 
			else if(headers['Content-Type'].indexOf('application/octed-stream') !== -1){
			  	payload = options.data;
			}
			else {
			  	payload = encodeUsingUrlEncoding(options.data);      
			}
		}

		if(method === 'GET') {
		  var queryString = [];
		  if(payload) {
		    queryString.push(payload);
		    payload = null;
		  }

		  if(!options.cache) {
		    queryString.push('_=' + (new Date()).getTime());
		  }

		  if(options.jsonp) {
		    queryString.push('callback=' + options.jsonp);
		    queryString.push('jsonp=' + options.jsonp);
		  }

		  queryString = '?' + queryString.join('&');
		  url += queryString !== '?' ? queryString : '';

		  if(options.jsonp) {
		    var head = document.getElementsByTagName('head')[0];
		    var script = document.createElement('script');
		    script.type = 'text/javascript';
		    script.src = url;
		    head.appendChild(script);        
		    return;
		  }
		}
		var xhrRef = null;
		getXhr(function (err, xhr) {
		  xhrRef = xhr;
		  if(err) return callback(err);
		  xhr.open(method, url, options.async || true);
		  for(var header in headers) {
		    if(headers.hasOwnProperty(header)) {
		      xhr.setRequestHeader(header, headers[header]);
		    }
		  }
		  xhr.timeout = 240000;
    	  xhr.ontimeout = function (){
    	  	callback(0, {
				text: function () {
				  	return 'Connection timeout';
				},
				json: function(){
					return {message: 'Connection timeout'}
				}
			});
    	  }
		  xhr.onerror = function(){
			callback(xhr.status, {
				text: function () {
				  	return xhr.statusText;
				},
				json: function(){
					return {message: xhr.statusText}
				}
			});
		  };
		  xhr.onreadystatechange = function () {
		    if(xhr.readyState === 4 && xhr.status !== 0) {
				if(!callback) return;
				var data = xhr.responseText || '';
				callback(xhr.status, {
					text: function () {
					  return data;
					},
					json: function () {
						if(data) return JSON.parse(data);
						return {};
					},
					headers: function(){
 						return xhr.getAllResponseHeaders();
  					},
                    log: function(){
                        return xhr.getResponseHeader('subkit-log');
                    }
				});
		    }
		  };

		  xhr.send(payload);
		});
		return xhrRef;
	}
	function initClientId(){
		var clientId = window.sessionStorage.getItem('clientId');
		if(!clientId) {
			clientId = Subkit.UUID();
			window.sessionStorage.setItem('clientId', clientId);
		}
		return clientId;
	}
	function poll(stream, callback) {
		var subscribeUrl = self.baseUrl + '/events/bind/' + stream;
		var request = null;
		var count = 1;

		(function _pollRef(){
			request = self.httpRequest.get(subscribeUrl, self.options, function(status, result){
				if(status !== 200) {
					if(subscriptions[stream]){
						callback({message: 'subscription error - retry'});
						setTimeout(function(){_pollRef(stream, callback);},300*count++);
					}
				}else{
					count = 1;
					result.json().forEach(function(item){
						callback(null, item);
					});
					if(subscriptions[stream]) _pollRef(stream, callback);
				}
			});
		})();

		return function(){
			return request;
		};
	}
};

Subkit.UUID = function () {
	// http://www.ietf.org/rfc/rfc4122.txt
	var s = [];
	var hexDigits = '0123456789abcdef';
	for (var i = 0; i < 36; i++) {
	    s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
	}
	s[14] = '4';  // bits 12-15 of the time_hi_and_version field to 0010
	s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1);  // bits 6-7 of the clock_seq_hi_and_reserved to 01
	s[8] = s[13] = s[18] = s[23] = '-';

	var uuid = s.join('');
	return uuid;
};

module.exports = Subkit
},{"./lib/events":1,"./lib/manage":2,"./lib/stores":3,"./lib/tasks":4,"q":7}],6:[function(require,module,exports){
// shim for using process in browser

var process = module.exports = {};

process.nextTick = (function () {
    var canSetImmediate = typeof window !== 'undefined'
    && window.setImmediate;
    var canPost = typeof window !== 'undefined'
    && window.postMessage && window.addEventListener
    ;

    if (canSetImmediate) {
        return function (f) { return window.setImmediate(f) };
    }

    if (canPost) {
        var queue = [];
        window.addEventListener('message', function (ev) {
            var source = ev.source;
            if ((source === window || source === null) && ev.data === 'process-tick') {
                ev.stopPropagation();
                if (queue.length > 0) {
                    var fn = queue.shift();
                    fn();
                }
            }
        }, true);

        return function nextTick(fn) {
            queue.push(fn);
            window.postMessage('process-tick', '*');
        };
    }

    return function nextTick(fn) {
        setTimeout(fn, 0);
    };
})();

process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];

process.binding = function (name) {
    throw new Error('process.binding is not supported');
}

// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};

},{}],7:[function(require,module,exports){
var process=require("__browserify_process");// vim:ts=4:sts=4:sw=4:
/*!
 *
 * Copyright 2009-2012 Kris Kowal under the terms of the MIT
 * license found at http://github.com/kriskowal/q/raw/master/LICENSE
 *
 * With parts by Tyler Close
 * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found
 * at http://www.opensource.org/licenses/mit-license.html
 * Forked at ref_send.js version: 2009-05-11
 *
 * With parts by Mark Miller
 * Copyright (C) 2011 Google 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.
 *
 */

(function (definition) {
    "use strict";

    // This file will function properly as a <script> tag, or a module
    // using CommonJS and NodeJS or RequireJS module formats.  In
    // Common/Node/RequireJS, the module exports the Q API and when
    // executed as a simple <script>, it creates a Q global instead.

    // Montage Require
    if (typeof bootstrap === "function") {
        bootstrap("promise", definition);

    // CommonJS
    } else if (typeof exports === "object" && typeof module === "object") {
        module.exports = definition();

    // RequireJS
    } else if (typeof define === "function" && define.amd) {
        define(definition);

    // SES (Secure EcmaScript)
    } else if (typeof ses !== "undefined") {
        if (!ses.ok()) {
            return;
        } else {
            ses.makeQ = definition;
        }

    // <script>
    } else if (typeof self !== "undefined") {
        self.Q = definition();

    } else {
        throw new Error("This environment was not anticipated by Q. Please file a bug.");
    }

})(function () {
"use strict";

var hasStacks = false;
try {
    throw new Error();
} catch (e) {
    hasStacks = !!e.stack;
}

// All code after this point will be filtered from stack traces reported
// by Q.
var qStartingLine = captureLine();
var qFileName;

// shims

// used for fallback in "allResolved"
var noop = function () {};

// Use the fastest possible means to execute a task in a future turn
// of the event loop.
var nextTick =(function () {
    // linked list of tasks (single, with head node)
    var head = {task: void 0, next: null};
    var tail = head;
    var flushing = false;
    var requestTick = void 0;
    var isNodeJS = false;

    function flush() {
        /* jshint loopfunc: true */

        while (head.next) {
            head = head.next;
            var task = head.task;
            head.task = void 0;
            var domain = head.domain;

            if (domain) {
                head.domain = void 0;
                domain.enter();
            }

            try {
                task();

            } catch (e) {
                if (isNodeJS) {
                    // In node, uncaught exceptions are considered fatal errors.
                    // Re-throw them synchronously to interrupt flushing!

                    // Ensure continuation if the uncaught exception is suppressed
                    // listening "uncaughtException" events (as domains does).
                    // Continue in next event to avoid tick recursion.
                    if (domain) {
                        domain.exit();
                    }
                    setTimeout(flush, 0);
                    if (domain) {
                        domain.enter();
                    }

                    throw e;

                } else {
                    // In browsers, uncaught exceptions are not fatal.
                    // Re-throw them asynchronously to avoid slow-downs.
                    setTimeout(function() {
                       throw e;
                    }, 0);
                }
            }

            if (domain) {
                domain.exit();
            }
        }

        flushing = false;
    }

    nextTick = function (task) {
        tail = tail.next = {
            task: task,
            domain: isNodeJS && process.domain,
            next: null
        };

        if (!flushing) {
            flushing = true;
            requestTick();
        }
    };

    if (typeof process !== "undefined" && process.nextTick) {
        // Node.js before 0.9. Note that some fake-Node environments, like the
        // Mocha test runner, introduce a `process` global without a `nextTick`.
        isNodeJS = true;

        requestTick = function () {
            process.nextTick(flush);
        };

    } else if (typeof setImmediate === "function") {
        // In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate
        if (typeof window !== "undefined") {
            requestTick = setImmediate.bind(window, flush);
        } else {
            requestTick = function () {
                setImmediate(flush);
            };
        }

    } else if (typeof MessageChannel !== "undefined") {
        // modern browsers
        // http://www.nonblocking.io/2011/06/windownexttick.html
        var channel = new MessageChannel();
        // At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create
        // working message ports the first time a page loads.
        channel.port1.onmessage = function () {
            requestTick = requestPortTick;
            channel.port1.onmessage = flush;
            flush();
        };
        var requestPortTick = function () {
            // Opera requires us to provide a message payload, regardless of
            // whether we use it.
            channel.port2.postMessage(0);
        };
        requestTick = function () {
            setTimeout(flush, 0);
            requestPortTick();
        };

    } else {
        // old browsers
        requestTick = function () {
            setTimeout(flush, 0);
        };
    }

    return nextTick;
})();

// Attempt to make generics safe in the face of downstream
// modifications.
// There is no situation where this is necessary.
// If you need a security guarantee, these primordials need to be
// deeply frozen anyway, and if you don’t need a security guarantee,
// this is just plain paranoid.
// However, this **might** have the nice side-effect of reducing the size of
// the minified code by reducing x.call() to merely x()
// See Mark Miller’s explanation of what this does.
// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
var call = Function.call;
function uncurryThis(f) {
    return function () {
        return call.apply(f, arguments);
    };
}
// This is equivalent, but slower:
// uncurryThis = Function_bind.bind(Function_bind.call);
// http://jsperf.com/uncurrythis

var array_slice = uncurryThis(Array.prototype.slice);

var array_reduce = uncurryThis(
    Array.prototype.reduce || function (callback, basis) {
        var index = 0,
            length = this.length;
        // concerning the initial value, if one is not provided
        if (arguments.length === 1) {
            // seek to the first value in the array, accounting
            // for the possibility that is is a sparse array
            do {
                if (index in this) {
                    basis = this[index++];
                    break;
                }
                if (++index >= length) {
                    throw new TypeError();
                }
            } while (1);
        }
        // reduce
        for (; index < length; index++) {
            // account for the possibility that the array is sparse
            if (index in this) {
                basis = callback(basis, this[index], index);
            }
        }
        return basis;
    }
);

var array_indexOf = uncurryThis(
    Array.prototype.indexOf || function (value) {
        // not a very good shim, but good enough for our one use of it
        for (var i = 0; i < this.length; i++) {
            if (this[i] === value) {
                return i;
            }
        }
        return -1;
    }
);

var array_map = uncurryThis(
    Array.prototype.map || function (callback, thisp) {
        var self = this;
        var collect = [];
        array_reduce(self, function (undefined, value, index) {
            collect.push(callback.call(thisp, value, index, self));
        }, void 0);
        return collect;
    }
);

var object_create = Object.create || function (prototype) {
    function Type() { }
    Type.prototype = prototype;
    return new Type();
};

var object_hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);

var object_keys = Object.keys || function (object) {
    var keys = [];
    for (var key in object) {
        if (object_hasOwnProperty(object, key)) {
            keys.push(key);
        }
    }
    return keys;
};

var object_toString = uncurryThis(Object.prototype.toString);

function isObject(value) {
    return value === Object(value);
}

// generator related shims

// FIXME: Remove this function once ES6 generators are in SpiderMonkey.
function isStopIteration(exception) {
    return (
        object_toString(exception) === "[object StopIteration]" ||
        exception instanceof QReturnValue
    );
}

// FIXME: Remove this helper and Q.return once ES6 generators are in
// SpiderMonkey.
var QReturnValue;
if (typeof ReturnValue !== "undefined") {
    QReturnValue = ReturnValue;
} else {
    QReturnValue = function (value) {
        this.value = value;
    };
}

// long stack traces

var STACK_JUMP_SEPARATOR = "From previous event:";

function makeStackTraceLong(error, promise) {
    // If possible, transform the error stack trace by removing Node and Q
    // cruft, then concatenating with the stack trace of `promise`. See #57.
    if (hasStacks &&
        promise.stack &&
        typeof error === "object" &&
        error !== null &&
        error.stack &&
        error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1
    ) {
        var stacks = [];
        for (var p = promise; !!p; p = p.source) {
            if (p.stack) {
                stacks.unshift(p.stack);
            }
        }
        stacks.unshift(error.stack);

        var concatedStacks = stacks.join("\n" + STACK_JUMP_SEPARATOR + "\n");
        error.stack = filterStackString(concatedStacks);
    }
}

function filterStackString(stackString) {
    var lines = stackString.split("\n");
    var desiredLines = [];
    for (var i = 0; i < lines.length; ++i) {
        var line = lines[i];

        if (!isInternalFrame(line) && !isNodeFrame(line) && line) {
            desiredLines.push(line);
        }
    }
    return desiredLines.join("\n");
}

function isNodeFrame(stackLine) {
    return stackLine.indexOf("(module.js:") !== -1 ||
           stackLine.indexOf("(node.js:") !== -1;
}

function getFileNameAndLineNumber(stackLine) {
    // Named functions: "at functionName (filename:lineNumber:columnNumber)"
    // In IE10 function name can have spaces ("Anonymous function") O_