usergrid-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From snoopd...@apache.org
Subject [02/51] [abbrv] Revert "updating with the lastest from usergrid-javascript-sdk"
Date Thu, 16 Jan 2014 17:29:58 GMT
http://git-wip-us.apache.org/repos/asf/incubator-usergrid/blob/4def2d7e/sdks/html5-javascript/usergrid.js
----------------------------------------------------------------------
diff --git a/sdks/html5-javascript/usergrid.js b/sdks/html5-javascript/usergrid.js
index b071781..948238b 100755
--- a/sdks/html5-javascript/usergrid.js
+++ b/sdks/html5-javascript/usergrid.js
@@ -1,836 +1,691 @@
 /*
-*  This module is a collection of classes designed to make working with
-*  the Apigee App Services API as easy as possible.
-*  Learn more at http://apigee.com/docs/usergrid
-*
-*   Copyright 2012 Apigee Corporation
-*
-*  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.
-*
-*  @author rod simpson (rod@apigee.com)
-*  @author matt dobson (matt@apigee.com)
-*  @author ryan bridges (rbridges@apigee.com)
-*/
-
-(function() {
-  var name = 'Usergrid', global = global||this, overwrittenName = global[name];
-  //authentication type constants for Node.js
-  var AUTH_CLIENT_ID = 'CLIENT_ID';
-  var AUTH_APP_USER = 'APP_USER';
-  var AUTH_NONE = 'NONE';
-  
-  if("undefined"===typeof console){
-    global.console = {
-      log: function() {},
-      warn: function() {},
-      error: function() {},
-      dir: function() {}  
-    };
-    }
-
-
-  function Usergrid() {};
-    Usergrid.Client = function(options) {
-    //usergrid enpoint
-    this.URI = options.URI || 'https://api.usergrid.com';
-
-    //Find your Orgname and Appname in the Admin portal (http://apigee.com/usergrid)
-    if (options.orgName) {
-      this.set('orgName', options.orgName);
-    }
-    if (options.appName) {
-      this.set('appName', options.appName);
-    }
-    if (options.appVersion) {
-      this.set('appVersion', options.appVersion);
-    }
+ *  This module is a collection of classes designed to make working with
+ *  the Appigee App Services API as easy as possible.
+ *  Learn more at http://apigee.com/docs/usergrid
+ *
+ *   Copyright 2012 Apigee Corporation
+ *
+ *  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.
+ *
+ *  @author rod simpson (rod@apigee.com)
+ *  @author matt dobson (matt@apigee.com)
+ *  @author ryan bridges (rbridges@apigee.com)
+ */
+
+
+//Hack around IE console.log
+window.console = window.console || {};
+window.console.log = window.console.log || function() {};
+
+//Usergrid namespace encapsulates this SDK
+window.Usergrid = window.Usergrid || {};
+Usergrid = Usergrid || {};
+Usergrid.USERGRID_SDK_VERSION = '0.10.07';
+
+Usergrid.Client = function(options) {
+  //usergrid enpoint
+  this.URI = options.URI || 'https://api.usergrid.com';
+
+  //Find your Orgname and Appname in the Admin portal (http://apigee.com/usergrid)
+  if (options.orgName) {
+    this.set('orgName', options.orgName);
+  }
+  if (options.appName) {
+    this.set('appName', options.appName);
+  }
+
+  //other options
+  this.buildCurl = options.buildCurl || false;
+  this.logging = options.logging || false;
+
+  //timeout and callbacks
+  this._callTimeout =  options.callTimeout || 30000; //default to 30 seconds
+  this._callTimeoutCallback =  options.callTimeoutCallback || null;
+  this.logoutCallback =  options.logoutCallback || null;
+};
 
-    //authentication data
-    this.authType = options.authType || AUTH_NONE;
-    this.clientId = options.clientId;
-    this.clientSecret = options.clientSecret;
-    this.setToken(options.token || null);
-
-    //other options
-    this.buildCurl = options.buildCurl || false;
-    this.logging = options.logging || false;
-
-    //timeout and callbacks
-    this._callTimeout = options.callTimeout || 30000; //default to 30 seconds
-    this._callTimeoutCallback = options.callTimeoutCallback || null;
-    this.logoutCallback = options.logoutCallback || null;
-  };
-
-    /*
-    *  Main function for making requests to the API using node.  
-    *  Use Usergrid.Client.prototype.request for cross-platform compatibility.
-
-    *
-    *  options object:
-    *  `method` - http method (GET, POST, PUT, or DELETE), defaults to GET
-    *  `qs` - object containing querystring values to be appended to the uri
-    *  `body` - object containing entity body for POST and PUT requests
-    *  `endpoint` - API endpoint, for example 'users/fred'
-    *  `mQuery` - boolean, set to true if running management query, defaults to false
-    *
-    *  @method _request_node
-    *  @public
-    *  @params {object} options
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Client.prototype._request_node = function(options, callback) {
-    global.request = global.request||require('request');
-    var request=global.request;
-    var self = this;
-    var method = options.method || 'GET';
-    var endpoint = options.endpoint;
-    var body = options.body || {};
-    var qs = options.qs || {};
-    var mQuery = options.mQuery || false; //is this a query to the management endpoint?
-    var orgName = this.get('orgName');
-    var appName = this.get('appName');
-    if (!mQuery && !orgName && !appName) {
-      if (typeof(this.logoutCallback) === 'function') {
+/*
+ *  Main function for making requests to the API.  Can be called directly.
+ *
+ *  options object:
+ *  `method` - http method (GET, POST, PUT, or DELETE), defaults to GET
+ *  `qs` - object containing querystring values to be appended to the uri
+ *  `body` - object containing entity body for POST and PUT requests
+ *  `endpoint` - API endpoint, for example 'users/fred'
+ *  `mQuery` - boolean, set to true if running management query, defaults to false
+ *
+ *  @method request
+ *  @public
+ *  @params {object} options
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.request = function (options, callback) {
+  var self = this;
+  var method = options.method || 'GET';
+  var endpoint = options.endpoint;
+  var body = options.body || {};
+  var qs = options.qs || {};
+  var mQuery = options.mQuery || false; //is this a query to the management endpoint?
+  var orgName = this.get('orgName');
+  var appName = this.get('appName');
+  if(!mQuery && !orgName && !appName){
+    if (typeof(this.logoutCallback) === 'function') {
       return this.logoutCallback(true, 'no_org_or_app_name_specified');
-      }
     }
-    if (mQuery) {
-      uri = this.URI + '/' + endpoint;
-    } else {
-      uri = this.URI + '/' + orgName + '/' + appName + '/' + endpoint;
+  }
+  if (mQuery) {
+    uri = this.URI + '/' + endpoint;
+  } else {
+    uri = this.URI + '/' + orgName + '/' + appName + '/' + endpoint;
+  }
+
+  if (self.getToken()) {
+    qs.access_token = self.getToken();
+    /* //could also use headers for the token
+     xhr.setRequestHeader("Authorization", "Bearer " + self.getToken());
+     xhr.withCredentials = true;
+     */
+  }
+
+  //append params to the path
+  var encoded_params = encodeParams(qs);
+  if (encoded_params) {
+    uri += "?" + encoded_params;
+  }
+
+  //stringify the body object
+  body = JSON.stringify(body);
+
+  //so far so good, so run the query
+  var xhr = new XMLHttpRequest();
+  xhr.open(method, uri, true);
+  //add content type = json if there is a json payload
+  if (body) {
+    xhr.setRequestHeader("Content-Type", "application/json");
+    xhr.setRequestHeader("Accept", "application/json");
+  }
+
+  // Handle response.
+  xhr.onerror = function(response) {
+    self._end = new Date().getTime();
+    if (self.logging) {
+      console.log('success (time: ' + self.calcTimeDiff() + '): ' + method + ' ' + uri);
     }
-
-    if (this.authType === AUTH_CLIENT_ID) {
-      qs.client_id = this.clientId;
-      qs.client_secret = this.clientSecret;
-    } else if (this.authType === AUTH_APP_USER) {
-      qs.access_token = self.getToken();
+    if (self.logging) {
+      console.log('Error: API call failed at the network level.');
+    }
+    //network error
+    clearTimeout(timeout);
+    var err = true;
+    if (typeof(callback) === 'function') {
+      callback(err, response);
     }
+  };
 
-    if (this.logging) {
-      console.log('calling: ' + method + ' ' + uri);
+  xhr.onload = function(response) {
+    //call timing, get time, then log the call
+    self._end = new Date().getTime();
+    if (self.logging) {
+      console.log('success (time: ' + self.calcTimeDiff() + '): ' + method + ' ' + uri);
     }
-    this._start = new Date().getTime();
-    var callOptions = {
-      method: method,
-      uri: uri,
-      json: body,
-      qs: qs
-    };
-    request(callOptions, function (err, r, data) {
-      if (self.buildCurl) {
-      options.uri = r.request.uri.href;
-      self.buildCurlCall(options);
-      }
-      self._end = new Date().getTime();
-      if(r.statusCode === 200) {
+    //call completed
+    clearTimeout(timeout);
+    //decode the response
+    try{
+      response = JSON.parse(xhr.responseText);
+    }catch (e){
+      response = {error:'unhandled_error',error_description:xhr.responseText};
+      xhr.status = xhr.status === 200 ? 400 : xhr.status;
+      console.error(e);
+    }
+    if (xhr.status != 200)   {
+      //there was an api error
+      var error = response.error;
+      var error_description = response.error_description;
       if (self.logging) {
-        console.log('success (time: ' + self.calcTimeDiff() + '): ' + method + ' ' + uri);
-      }
-      callback(err, data);
-      } else {
-      err = true;
-      if ((r.error === 'auth_expired_session_token') ||
-        (r.error === 'auth_missing_credentials')   ||
-        (r.error == 'auth_unverified_oath')       ||
-        (r.error === 'expired_token')   ||
-        (r.error === 'unauthorized')   ||
-        (r.error === 'auth_invalid')) {
-        //this error type means the user is not authorized. If a logout function is defined, call it
-        var error = r.body.error;
-        var errorDesc = r.body.error_description;
-        if (self.logging) {
-        console.log('Error (' + r.statusCode + ')(' + error + '): ' + errorDesc)
-        }
+        console.log('Error (' + xhr.status + ')(' + error + '): ' + error_description);
+      }
+      if ( (error == "auth_expired_session_token") ||
+        (error == "auth_missing_credentials")   ||
+        (error == "auth_unverified_oath")       ||
+        (error == "expired_token")              ||
+        (error == "unauthorized")               ||
+        (error == "auth_invalid")) {
+        //these errors mean the user is not authorized for whatever reason. If a logout function is defined, call it
         //if the user has specified a logout callback:
         if (typeof(self.logoutCallback) === 'function') {
-        self.logoutCallback(err, data);
-        } else  if (typeof(callback) === 'function') {
-        callback(err, data);
-        }
-      } else {
-        var error = r.body.error;
-        var errorDesc = r.body.error_description;
-        if (self.logging) {
-        console.log('Error (' + r.statusCode + ')(' + error + '): ' + errorDesc);
-        }
-        if (typeof(callback) === 'function') {
-        callback(err, data);
+          return self.logoutCallback(true, response);
         }
       }
+      if (typeof(callback) === 'function') {
+        callback(true, response);
       }
-    });
-    }
-    /*
-    *  Main function for making requests to the API using a browser.  
-    *  Use Usergrid.Client.prototype.request for cross-platform compatibility.
-
-    *
-    *  options object:
-    *  `method` - http method (GET, POST, PUT, or DELETE), defaults to GET
-    *  `qs` - object containing querystring values to be appended to the uri
-    *  `body` - object containing entity body for POST and PUT requests
-    *  `endpoint` - API endpoint, for example 'users/fred'
-    *  `mQuery` - boolean, set to true if running management query, defaults to false
-    *
-    *  @method _request_node
-    *  @public
-    *  @params {object} options
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Client.prototype._request_xhr = function(options, callback) {
-    var self = this;
-    var method = options.method || 'GET';
-    var endpoint = options.endpoint;
-    var body = options.body || {};
-    var qs = options.qs || {};
-    var mQuery = options.mQuery || false; //is this a query to the management endpoint?
-    var orgName = this.get('orgName');
-    var appName = this.get('appName');
-    if (!mQuery && !orgName && !appName) {
-      if (typeof(this.logoutCallback) === 'function') {
-      return this.logoutCallback(true, 'no_org_or_app_name_specified');
-      }
-    }
-    var uri;
-    if (mQuery) {
-      uri = this.URI + '/' + endpoint;
     } else {
-      uri = this.URI + '/' + orgName + '/' + appName + '/' + endpoint;
-    }
-
-    if (self.getToken()) {
-      qs.access_token = self.getToken();
-      /* //could also use headers for the token
-      xhr.setRequestHeader("Authorization", "Bearer " + self.getToken());
-      xhr.withCredentials = true;
-      */
-    }
-
-    //append params to the path
-    var encoded_params = encodeParams(qs);
-    if (encoded_params) {
-      uri += "?" + encoded_params;
-    }
-
-    //stringify the body object
-    body = JSON.stringify(body);
-
-    //so far so good, so run the query
-    var xhr = new XMLHttpRequest();
-    xhr.open(method, uri, true);
-    //add content type = json if there is a json payload
-    if (body) {
-      xhr.setRequestHeader("Content-Type", "application/json");
-      xhr.setRequestHeader("Accept", "application/json");
-    }
-
-    // Handle response.
-    xhr.onerror = function(response) {
-      self._end = new Date().getTime();
-      if (self.logging) {
-      console.log('success (time: ' + self.calcTimeDiff() + '): ' + method + ' ' + uri);
-      }
-      if (self.logging) {
-      console.log('Error: API call failed at the network level.');
-      }
-      //network error
-      clearTimeout(timeout);
-      var err = true;
       if (typeof(callback) === 'function') {
-      callback(err, response);
+        callback(false, response);
       }
-    };
-
-    xhr.onload = function(response) {
-      //call timing, get time, then log the call
-      self._end = new Date().getTime();
-      if (self.logging) {
-      console.log('success (time: ' + self.calcTimeDiff() + '): ' + method + ' ' + uri);
-      }
-      //call completed
-      clearTimeout(timeout);
-      //decode the response
-      try{
-        response = JSON.parse(xhr.responseText);
-      }catch (e){
-        response = {error:'unhandled_error',error_description:xhr.responseText};
-        xhr.status = xhr.status === 200 ? 400 : xhr.status;
-        console.error(e);
-      }
-      if (xhr.status != 200) {
-          //there was an api error
-          var error = response.error;
-          var error_description = response.error_description;
-          if (self.logging) {
-            console.log('Error (' + xhr.status + ')(' + error + '): ' + error_description);
-          }
-          if ((error == "auth_expired_session_token") ||
-            (error == "auth_missing_credentials") ||
-            (error == "auth_unverified_oath") ||
-            (error == "expired_token") ||
-            (error == "unauthorized") ||
-            (error == "auth_invalid")) {
-            //these errors mean the user is not authorized for whatever reason. If a logout function is defined, call it
-            //if the user has specified a logout callback:
-            if (typeof(self.logoutCallback) === 'function') {
-              return self.logoutCallback(true, response);
-            }
-          }
-          if (typeof(callback) === 'function') {
-            callback(true, response);
-          }
-        } else {
-          if (typeof(callback) === 'function') {
-            callback(false, response);
-          }
-        }
-    };
+    }
+  };
 
-    var timeout = setTimeout(
-      function() {
+  var timeout = setTimeout(
+    function() {
       xhr.abort();
       if (self._callTimeoutCallback === 'function') {
         self._callTimeoutCallback('API CALL TIMEOUT');
       } else {
         self.callback('API CALL TIMEOUT');
       }
-      },
-      self._callTimeout); //set for 30 seconds
+    },
+    self._callTimeout); //set for 30 seconds
 
-    if (this.logging) {
-      console.log('calling: ' + method + ' ' + uri);
-    }
-    if (this.buildCurl) {
-      var curlOptions = {
-      uri: uri,
-      body: body,
-      method: method
-      };
-      this.buildCurlCall(curlOptions);
+  if (this.logging) {
+    console.log('calling: ' + method + ' ' + uri);
+  }
+  if (this.buildCurl) {
+    var curlOptions = {
+      uri:uri,
+      body:body,
+      method:method
     }
-    this._start = new Date().getTime();
-    xhr.send(body);
-    };
-
-    /*
-    *  Main function for making requests to the API using node.  You may call this method directly
-    *
-    *  options object:
-    *  `method` - http method (GET, POST, PUT, or DELETE), defaults to GET
-    *  `qs` - object containing querystring values to be appended to the uri
-    *  `body` - object containing entity body for POST and PUT requests
-    *  `endpoint` - API endpoint, for example 'users/fred'
-    *  `mQuery` - boolean, set to true if running management query, defaults to false
-    *
-    *  @method _request_node
-    *  @public
-    *  @params {object} options
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Client.prototype.request = function(options, callback) {
-    if("undefined" !== typeof window){
-      Usergrid.Client.prototype._request_xhr.apply(this, arguments);
-    }else{
-      Usergrid.Client.prototype._request_node.apply(this, arguments);;
-    }
-    }
-
-    /*
-     *  function for building asset urls
-     *
-     *  @method buildAssetURL
-     *  @public
-     *  @params {string} uuid
-     *  @return {string} assetURL
-     */
-     Usergrid.Client.prototype.buildAssetURL = function(uuid) {
-     var self = this;
-     var qs = {};
-     var assetURL = this.URI + '/' + this.orgName + '/' + this.appName + '/assets/' + uuid + '/data';
-
-     if (self.getToken()) {
-      qs.access_token = self.getToken();
-     }
-
-     //append params to the path
-     var encoded_params = encodeParams(qs);
-     if (encoded_params) {
-       assetURL += "?" + encoded_params;
-     }
-
-     return assetURL;
-    };
+    this.buildCurlCall(curlOptions);
+  }
+  this._start = new Date().getTime();
+  xhr.send(body);
+}
 
-    /*
-     *  Main function for creating new groups. Call this directly.
-     *
-     *  @method createGroup
-     *  @public
-     *  @params {string} path
-     *  @param {function} callback
-     *  @return {callback} callback(err, data)
-     */
-    Usergrid.Client.prototype.createGroup = function(options, callback) {
-    var getOnExist = options.getOnExist || false;
+/*
+ *  function for building asset urls
+ *
+ *  @method buildAssetURL
+ *  @public
+ *  @params {string} uuid
+ *  @return {string} assetURL
+ */
+Usergrid.Client.prototype.buildAssetURL = function(uuid) {
+  var self = this;
+  var qs = {};
+  var assetURL = this.URI + '/' + this.orgName + '/' + this.appName + '/assets/' + uuid + '/data';
+
+  if (self.getToken()) {
+    qs.access_token = self.getToken();
+  }
+
+  //append params to the path
+  var encoded_params = encodeParams(qs);
+  if (encoded_params) {
+    assetURL += "?" + encoded_params;
+  }
+
+  return assetURL;
+};
 
-    options = {
-      path: options.path,
-      client: this,
-      data: options
-    };
+/*
+ *  Main function for creating new groups. Call this directly.
+ *
+ *  @method createGroup
+ *  @public
+ *  @params {string} path
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.createGroup = function(options, callback) {
+  var getOnExist = options.getOnExist || false;
+
+  options = {
+    path: options.path,
+    client: this,
+    data: options
+  };
 
-    var group = new Usergrid.Group(options);
-      group.fetch(function(err, data) {
-      var okToSave = (err && 'service_resource_not_found' === data.error || 'no_name_specified' === data.error || 'null_pointer' === data.error) || (!err && getOnExist);
-      if (okToSave) {
-        group.save(function(err, data) {
+  var group = new Usergrid.Group(options);
+  group.fetch(function(err, data){
+    var okToSave = (err && 'service_resource_not_found' === data.error || 'no_name_specified' === data.error || 'null_pointer' === data.error) || (!err && getOnExist);
+    if (okToSave) {
+      group.save(function(err, data){
         if (typeof(callback) === 'function') {
-        callback(err, group);
+          callback(err, group);
         }
       });
-      } else {
-        if (typeof(callback) === 'function') {
+    } else {
+      if(typeof(callback) === 'function') {
         callback(err, group);
       }
-      }
-    });
-    };
+    }
+  });
+};
 
-    /*
-    *  Main function for creating new entities - should be called directly.
-    *
-    *  options object: options {data:{'type':'collection_type', 'key':'value'}, uuid:uuid}}
-    *
-    *  @method createEntity
-    *  @public
-    *  @params {object} options
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Client.prototype.createEntity = function(options, callback) {
-    // todo: replace the check for new / save on not found code with simple save
-    // when users PUT on no user fix is in place.
-    /*
-    options = {
-      client:this,
-      data:options
-    }
-    var entity = new Usergrid.Entity(options);
-    entity.save(function(err, data) {
-      if (typeof(callback) === 'function') {
-      callback(err, entity);
-      }
-    });
-    */
-    var getOnExist = options.getOnExist || false; //if true, will return entity if one already exists
-    options = {
-      client: this,
-      data: options
-    };
-    var entity = new Usergrid.Entity(options);
-    entity.fetch(function(err, data) {
-      //if the fetch doesn't find what we are looking for, or there is no error, do a save
-      var okToSave = (err && 'service_resource_not_found' === data.error || 'no_name_specified' === data.error || 'null_pointer' === data.error) || (!err && getOnExist);
-      if (okToSave) {
+/*
+ *  Main function for creating new entities - should be called directly.
+ *
+ *  options object: options {data:{'type':'collection_type', 'key':'value'}, uuid:uuid}}
+ *
+ *  @method createEntity
+ *  @public
+ *  @params {object} options
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.createEntity = function (options, callback) {
+  // todo: replace the check for new / save on not found code with simple save
+  // when users PUT on no user fix is in place.
+  /*
+   var options = {
+   client:this,
+   data:options
+   }
+   var entity = new Usergrid.Entity(options);
+   entity.save(function(err, data) {
+   if (typeof(callback) === 'function') {
+   callback(err, entity);
+   }
+   });
+   */
+  var getOnExist = options.getOnExist || false; //if true, will return entity if one already exists
+  var options = {
+    client:this,
+    data:options
+  };
+  var entity = new Usergrid.Entity(options);
+  entity.fetch(function(err, data) {
+    //if the fetch doesn't find what we are looking for, or there is no error, do a save
+    var okToSave = (err && 'service_resource_not_found' === data.error || 'no_name_specified' === data.error || 'null_pointer' === data.error) || (!err && getOnExist);
+    if(okToSave) {
       entity.set(options.data); //add the data again just in case
       entity.save(function(err, data) {
         if (typeof(callback) === 'function') {
-        callback(err, entity, data);
+          callback(err, entity, data);
         }
       });
-      } else {
+    } else {
       if (typeof(callback) === 'function') {
         callback(err, entity, data);
       }
-      }
-    });
+    }
+  });
 
-    };
+};
 
-    /*
-     *  Main function for getting existing entities - should be called directly.
-     *
-     *  You must supply a uuid or (username or name). Username only applies to users.
-     *  Name applies to all custom entities
-     *
-     *  options object: options {data:{'type':'collection_type', 'name':'value', 'username':'value'}, uuid:uuid}}
-     *
-     *  @method createEntity
-     *  @public
-     *  @params {object} options
-     *  @param {function} callback
-     *  @return {callback} callback(err, data)
-     */
-    Usergrid.Client.prototype.getEntity = function(options, callback) {
-    options = {
-      client: this,
-      data: options
-    };
-    var entity = new Usergrid.Entity(options);
-    entity.fetch(function(err, data) {
-      if (typeof(callback) === 'function') {
+/*
+ *  Main function for getting existing entities - should be called directly.
+ *
+ *  You must supply a uuid or (username or name). Username only applies to users.
+ *  Name applies to all custom entities
+ *
+ *  options object: options {data:{'type':'collection_type', 'name':'value', 'username':'value'}, uuid:uuid}}
+ *
+ *  @method createEntity
+ *  @public
+ *  @params {object} options
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.getEntity = function (options, callback) {
+  var options = {
+    client:this,
+    data:options
+  }
+  var entity = new Usergrid.Entity(options);
+  entity.fetch(function(err, data) {
+    if (typeof(callback) === 'function') {
       callback(err, entity, data);
-      }
-    });
-    };
+    }
+  });
+};
 
-    /*
-     *  Main function for restoring an entity from serialized data.
-     *
-     *  serializedObject should have come from entityObject.serialize();
-     *
-     *  @method restoreEntity
-     *  @public
-     *  @param {string} serializedObject
-     *  @return {object} Entity Object
-     */
-    Usergrid.Client.prototype.restoreEntity = function(serializedObject) {
-    var data = JSON.parse(serializedObject);
-    options = {
-      client: this,
-      data: data
-    };
-    var entity = new Usergrid.Entity(options);
-    return entity;
-    };
+/*
+ *  Main function for restoring an entity from serialized data.
+ *
+ *  serializedObject should have come from entityObject.serialize();
+ *
+ *  @method restoreEntity
+ *  @public
+ *  @param {string} serializedObject
+ *  @return {object} Entity Object
+ */
+Usergrid.Client.prototype.restoreEntity = function (serializedObject) {
+  var data = JSON.parse(serializedObject);
+  var options = {
+    client:this,
+    data:data
+  }
+  var entity = new Usergrid.Entity(options);
+  return entity;
+};
 
-    /*
-    *  Main function for creating new collections - should be called directly.
-    *
-    *  options object: options {client:client, type: type, qs:qs}
-    *
-    *  @method createCollection
-    *  @public
-    *  @params {object} options
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Client.prototype.createCollection = function(options, callback) {
-    options.client = this;
-    var collection = new Usergrid.Collection(options, function(err, data) {
-      if (typeof(callback) === 'function') {
+/*
+ *  Main function for creating new collections - should be called directly.
+ *
+ *  options object: options {client:client, type: type, qs:qs}
+ *
+ *  @method createCollection
+ *  @public
+ *  @params {object} options
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.createCollection = function (options, callback) {
+  options.client = this;
+  var collection = new Usergrid.Collection(options, function(err, data) {
+    if (typeof(callback) === 'function') {
       callback(err, collection, data);
-      }
-    });
-    };
+    }
+  });
+};
 
-    /*
-     *  Main function for restoring a collection from serialized data.
-     *
-     *  serializedObject should have come from collectionObject.serialize();
-     *
-     *  @method restoreCollection
-     *  @public
-     *  @param {string} serializedObject
-     *  @return {object} Collection Object
-     */
-    Usergrid.Client.prototype.restoreCollection = function(serializedObject) {
-    var data = JSON.parse(serializedObject);
-    data.client = this;
-    var collection = new Usergrid.Collection(data);
-    return collection;
-    };
+/*
+ *  Main function for restoring a collection from serialized data.
+ *
+ *  serializedObject should have come from collectionObject.serialize();
+ *
+ *  @method restoreCollection
+ *  @public
+ *  @param {string} serializedObject
+ *  @return {object} Collection Object
+ */
+Usergrid.Client.prototype.restoreCollection = function (serializedObject) {
+  var data = JSON.parse(serializedObject);
+  data.client = this;
+  var collection = new Usergrid.Collection(data);
+  return collection;
+};
 
-    /*
-     *  Main function for retrieving a user's activity feed.
-     *
-     *  @method getFeedForUser
-     *  @public
-     *  @params {string} username
-     *  @param {function} callback
-     *  @return {callback} callback(err, data, activities)
-     */
-    Usergrid.Client.prototype.getFeedForUser = function(username, callback) {
-    var options = {
-      method: "GET",
-      endpoint: "users/" + username + "/feed"
-    };
+/*
+ *  Main function for retrieving a user's activity feed.
+ *
+ *  @method getFeedForUser
+ *  @public
+ *  @params {string} username
+ *  @param {function} callback
+ *  @return {callback} callback(err, data, activities)
+ */
+Usergrid.Client.prototype.getFeedForUser = function(username, callback) {
+  var options = {
+    method: "GET",
+    endpoint: "users/"+username+"/feed"
+  };
 
-      this.request(options, function(err, data) {
-      if (typeof(callback) === "function") {
-        if (err) {
+  this.request(options, function(err, data){
+    if(typeof(callback) === "function") {
+      if(err) {
         callback(err);
       } else {
         callback(err, data, data.entities);
       }
-      }
-    });
-    };
+    }
+  });
+};
 
-    /*
-    *  Function for creating new activities for the current user - should be called directly.
-    *
-    *  //user can be any of the following: "me", a uuid, a username
-    *  Note: the "me" alias will reference the currently logged in user (e.g. 'users/me/activties')
-    *
-    *  //build a json object that looks like this:
-    *  var options =
-    *  {
-    *    "actor" : {
-    *      "displayName" :"myusername",
-    *      "uuid" : "myuserid",
-    *      "username" : "myusername",
-    *      "email" : "myemail",
-    *      "picture": "http://path/to/picture",
-    *      "image" : {
-    *          "duration" : 0,
-    *          "height" : 80,
-    *          "url" : "http://www.gravatar.com/avatar/",
-    *          "width" : 80
-    *      },
-    *    },
-    *    "verb" : "post",
-    *    "content" : "My cool message",
-    *    "lat" : 48.856614,
-    *    "lon" : 2.352222
-    *  }
-    *
-    *  @method createEntity
-    *  @public
-    *  @params {string} user // "me", a uuid, or a username
-    *  @params {object} options
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Client.prototype.createUserActivity = function(user, options, callback) {
-      options.type = 'users/' + user + '/activities';
-    options = {
-      client: this,
-      data: options
-    };
-    var entity = new Usergrid.Entity(options);
-    entity.save(function(err, data) {
-      if (typeof(callback) === 'function') {
+/*
+ *  Function for creating new activities for the current user - should be called directly.
+ *
+ *  //user can be any of the following: "me", a uuid, a username
+ *  Note: the "me" alias will reference the currently logged in user (e.g. 'users/me/activties')
+ *
+ *  //build a json object that looks like this:
+ *  var options =
+ *  {
+ *    "actor" : {
+ *      "displayName" :"myusername",
+ *      "uuid" : "myuserid",
+ *      "username" : "myusername",
+ *      "email" : "myemail",
+ *      "picture": "http://path/to/picture",
+ *      "image" : {
+ *          "duration" : 0,
+ *          "height" : 80,
+ *          "url" : "http://www.gravatar.com/avatar/",
+ *          "width" : 80
+ *      },
+ *    },
+ *    "verb" : "post",
+ *    "content" : "My cool message",
+ *    "lat" : 48.856614,
+ *    "lon" : 2.352222
+ *  }
+ *
+ *  @method createEntity
+ *  @public
+ *  @params {string} user // "me", a uuid, or a username
+ *  @params {object} options
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.createUserActivity = function (user, options, callback) {
+  options.type = 'users/'+user+'/activities';
+  var options = {
+    client:this,
+    data:options
+  }
+  var entity = new Usergrid.Entity(options);
+  entity.save(function(err, data) {
+    if (typeof(callback) === 'function') {
       callback(err, entity);
-      }
-    });
-    };
+    }
+  });
+};
 
-    /*
-     *  Function for creating user activities with an associated user entity.
-     *
-     *  user object:
-     *  The user object passed into this function is an instance of Usergrid.Entity.
-     *
-     *  @method createUserActivityWithEntity
-     *  @public
-     *  @params {object} user
-     *  @params {string} content
-     *  @param {function} callback
-     *  @return {callback} callback(err, data)
-     */
-    Usergrid.Client.prototype.createUserActivityWithEntity = function(user, content, callback) {
-    var username = user.get("username");
-    var options = {
-      actor: {
-        "displayName": username,
-        "uuid": user.get("uuid"),
-        "username": username,
-        "email": user.get("email"),
-        "picture": user.get("picture"),
+/*
+ *  Function for creating user activities with an associated user entity.
+ *
+ *  user object:
+ *  The user object passed into this function is an instance of Usergrid.Entity.
+ *
+ *  @method createUserActivityWithEntity
+ *  @public
+ *  @params {object} user
+ *  @params {string} content
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.createUserActivityWithEntity = function(user, content, callback) {
+  var username = user.get("username");
+  var options = {
+    actor: {
+      "displayName":username,
+      "uuid":user.get("uuid"),
+      "username":username,
+      "email":user.get("email"),
+      "picture":user.get("picture"),
       "image": {
-        "duration": 0,
-        "height": 80,
-        "url": user.get("picture"),
-        "width": 80
-       },
+        "duration":0,
+        "height":80,
+        "url":user.get("picture"),
+        "width":80
       },
-      "verb": "post",
-      "content": content
-      };
+    },
+    "verb":"post",
+    "content":content
+  };
 
-    this.createUserActivity(username, options, callback);
+  this.createUserActivity(username, options, callback);
 
-    };
-
-    /*
-    *  A private method to get call timing of last call
-    */
-    Usergrid.Client.prototype.calcTimeDiff = function() {
-     var seconds = 0;
-     var time = this._end - this._start;
-     try {
-      seconds = ((time / 10) / 60).toFixed(2);
-      } catch (e) {
-      return 0;
-      }
-     return seconds;
-    };
+};
 
-    /*
-     *  A public method to store the OAuth token for later use - uses localstorage if available
-     *
-     *  @method setToken
-     *  @public
-     *  @params {string} token
-     *  @return none
-     */
-    Usergrid.Client.prototype.setToken = function(token) {
-    this.set('token', token);
-    };
+/*
+ *  A private method to get call timing of last call
+ */
+Usergrid.Client.prototype.calcTimeDiff = function () {
+  var seconds = 0;
+  var time = this._end - this._start;
+  try {
+    seconds = ((time/10) / 60).toFixed(2);
+  } catch(e) {
+    return 0;
+  }
+  return seconds;
+};
 
-    /*
-     *  A public method to get the OAuth token
-     *
-     *  @method getToken
-     *  @public
-     *  @return {string} token
-     */
-    Usergrid.Client.prototype.getToken = function() {
-    return this.get('token');
-    };
+/*
+ *  A public method to store the OAuth token for later use - uses localstorage if available
+ *
+ *  @method setToken
+ *  @public
+ *  @params {string} token
+ *  @return none
+ */
+Usergrid.Client.prototype.setToken = function (token) {
+  this.set('token', token);
+};
 
-    Usergrid.Client.prototype.setObject = function(key, value) {
+/*
+ *  A public method to get the OAuth token
+ *
+ *  @method getToken
+ *  @public
+ *  @return {string} token
+ */
+Usergrid.Client.prototype.getToken = function () {
+  return this.get('token');
+};
+
+Usergrid.Client.prototype.setObject = function(key, value) {
+  if (value) {
+    value = JSON.stringify(value);
+  }
+  this.set(key, value);
+};
+
+Usergrid.Client.prototype.set = function (key, value) {
+  var keyStore =  'apigee_' + key;
+  this[key] = value;
+  if(typeof(Storage)!=="undefined"){
     if (value) {
-      value = JSON.stringify(value);
-    }
-    this.set(key, value);
-    };
-
-    Usergrid.Client.prototype.set = function(key, value) {
-      var keyStore = 'apigee_' + key;
-    this[key] = value;
-      if (typeof(Storage) !== "undefined") {
-      if (value) {
       localStorage.setItem(keyStore, value);
-      } else {
+    } else {
       localStorage.removeItem(keyStore);
-      }
     }
-    };
+  }
+};
 
-    Usergrid.Client.prototype.getObject = function(key) {
-    return JSON.parse(this.get(key));
-    };
+Usergrid.Client.prototype.getObject = function(key) {
+  return JSON.parse(this.get(key));
+};
 
-    Usergrid.Client.prototype.get = function(key) {
-    var keyStore = 'apigee_' + key;
-    if (this[key]) {
-      return this[key];
-      } else if (typeof(Storage) !== "undefined") {
-      return localStorage.getItem(keyStore);
-    }
-    return null;
-    };
+Usergrid.Client.prototype.get = function (key) {
+  var keyStore = 'apigee_' + key;
+  if (this[key]) {
+    return this[key];
+  } else if(typeof(Storage)!=="undefined") {
+    return localStorage.getItem(keyStore);
+  }
+  return null;
+};
 
-    /*
-     * A public facing helper method for signing up users
-     *
-     * @method signup
-     * @public
-     * @params {string} username
-     * @params {string} password
-     * @params {string} email
-     * @params {string} name
-     * @param {function} callback
-     * @return {callback} callback(err, data)
-     */
-    Usergrid.Client.prototype.signup = function(username, password, email, name, callback) {
-    var self = this;
-    var options = {
-      type: "users",
-      username: username,
-      password: password,
-      email: email,
-      name: name
-    };
+/*
+ * A public facing helper method for signing up users
+ *
+ * @method signup
+ * @public
+ * @params {string} username
+ * @params {string} password
+ * @params {string} email
+ * @params {string} name
+ * @param {function} callback
+ * @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.signup = function(username, password, email, name, callback) {
+  var self = this;
+  var options = {
+    type:"users",
+    username:username,
+    password:password,
+    email:email,
+    name:name
+  };
 
-    this.createEntity(options, callback);
-    };
+  this.createEntity(options, callback);
+};
 
-    /*
-    *
-    *  A public method to log in an app user - stores the token for later use
-    *
-    *  @method login
-    *  @public
-    *  @params {string} username
-    *  @params {string} password
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Client.prototype.login = function(username, password, callback) {
-    var self = this;
-    var options = {
-      method: 'POST',
-      endpoint: 'token',
-      body: {
+/*
+ *
+ *  A public method to log in an app user - stores the token for later use
+ *
+ *  @method login
+ *  @public
+ *  @params {string} username
+ *  @params {string} password
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.login = function (username, password, callback) {
+  var self = this;
+  var options = {
+    method:'POST',
+    endpoint:'token',
+    body:{
       username: username,
       password: password,
       grant_type: 'password'
-      }
-    };
-    this.request(options, function(err, data) {
-      var user = {};
-      if (err && self.logging) {
+    }
+  };
+  this.request(options, function(err, data) {
+    var user = {};
+    if (err && self.logging) {
       console.log('error trying to log user in');
-      } else {
-      options = {
-        client: self,
-        data: data.user
+    } else {
+      var options = {
+        client:self,
+        data:data.user
       };
       user = new Usergrid.Entity(options);
       self.setToken(data.access_token);
-      }
-      if (typeof(callback) === 'function') {
+    }
+    if (typeof(callback) === 'function') {
       callback(err, data, user);
-      }
-    });
-    };
+    }
+  });
+};
 
 
-    Usergrid.Client.prototype.reAuthenticateLite = function(callback) {
-    var self = this;
-    var options = {
-      method: 'GET',
-      endpoint: 'management/me',
-      mQuery: true
-    };
-    this.request(options, function(err, response) {
-      if (err && self.logging) {
+Usergrid.Client.prototype.reAuthenticateLite = function (callback) {
+  var self = this;
+  var options = {
+    method:'GET',
+    endpoint:'management/me',
+    mQuery:true
+  };
+  this.request(options, function(err, response) {
+    if (err && self.logging) {
       console.log('error trying to re-authenticate user');
-      } else {
+    } else {
 
       //save the re-authed token and current email/username
       self.setToken(response.access_token);
 
-      }
-      if (typeof(callback) === 'function') {
+    }
+    if (typeof(callback) === 'function') {
       callback(err);
-      }
-    });
-    };
+    }
+  });
+};
 
 
-    Usergrid.Client.prototype.reAuthenticate = function(email, callback) {
-    var self = this;
-    var options = {
-      method: 'GET',
-      endpoint: 'management/users/' + email,
-      mQuery: true
-    };
-    this.request(options, function(err, response) {
-      var organizations = {};
-      var applications = {};
-      var user = {};
-      var data;
-      if (err && self.logging) {
+Usergrid.Client.prototype.reAuthenticate = function (email, callback) {
+  var self = this;
+  var options = {
+    method:'GET',
+    endpoint:'management/users/'+email,
+    mQuery:true
+  };
+  this.request(options, function(err, response) {
+    var organizations = {};
+    var applications = {};
+    var user = {};
+    var data;
+    if (err && self.logging) {
       console.log('error trying to full authenticate user');
-      } else {
+    } else {
       data = response.data;
       self.setToken(data.token);
       self.set('email', data.email);
@@ -843,14 +698,14 @@
 
 
       var userData = {
-        "username": data.username,
-        "email": data.email,
-        "name": data.name,
-        "uuid": data.uuid
+        "username" : data.username,
+        "email" : data.email,
+        "name" : data.name,
+        "uuid" : data.uuid
       };
-      options = {
-        client: self,
-        data: userData
+      var options = {
+        client:self,
+        data:userData
       };
       user = new Usergrid.Entity(options);
 
@@ -859,9 +714,9 @@
       try {
         //if we have an org stored, then use that one. Otherwise, use the first one.
         var existingOrg = self.get('orgName');
-        org = (organizations[existingOrg]) ? organizations[existingOrg] : organizations[Object.keys(organizations)[0]];
+        org = (organizations[existingOrg])?organizations[existingOrg]:organizations[Object.keys(organizations)[0]];
         self.set('orgName', org.name);
-        } catch (e) {
+      } catch(e) {
         err = true;
         if (self.logging) {
           console.log('error selecting org');
@@ -874,708 +729,717 @@
       self.setObject('organizations', organizations);
       self.setObject('applications', applications);
 
-      }
-      if (typeof(callback) === 'function') {
+    }
+    if (typeof(callback) === 'function') {
       callback(err, data, user, organizations, applications);
-      }
-    });
-    };
+    }
+  });
+};
 
-    /*
-    *  A public method to log in an app user with facebook - stores the token for later use
-    *
-    *  @method loginFacebook
-    *  @public
-    *  @params {string} username
-    *  @params {string} password
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Client.prototype.loginFacebook = function(facebookToken, callback) {
-    var self = this;
-    var options = {
-      method: 'GET',
-      endpoint: 'auth/facebook',
-      qs: {
+/*
+ *  A public method to log in an app user with facebook - stores the token for later use
+ *
+ *  @method loginFacebook
+ *  @public
+ *  @params {string} username
+ *  @params {string} password
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.loginFacebook = function (facebookToken, callback) {
+  var self = this;
+  var options = {
+    method:'GET',
+    endpoint:'auth/facebook',
+    qs:{
       fb_access_token: facebookToken
-      }
-    };
-    this.request(options, function(err, data) {
-      var user = {};
-      if (err && self.logging) {
+    }
+  };
+  this.request(options, function(err, data) {
+    var user = {};
+    if (err && self.logging) {
       console.log('error trying to log user in');
-      } else {
+    } else {
       var options = {
         client: self,
         data: data.user
       }
       user = new Usergrid.Entity(options);
       self.setToken(data.access_token);
-      }
-      if (typeof(callback) === 'function') {
+    }
+    if (typeof(callback) === 'function') {
       callback(err, data, user);
-      }
-    });
-    };
+    }
+  });
+};
 
-    /*
-    *  A public method to get the currently logged in user entity
-    *
-    *  @method getLoggedInUser
-    *  @public
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Client.prototype.getLoggedInUser = function(callback) {
-    if (!this.getToken()) {
-      callback(true, null, null);
-    } else {
-      var self = this;
-      var options = {
-        method: 'GET',
-        endpoint: 'users/me'
-      };
-      this.request(options, function(err, data) {
+/*
+ *  A public method to get the currently logged in user entity
+ *
+ *  @method getLoggedInUser
+ *  @public
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Client.prototype.getLoggedInUser = function (callback) {
+  if (!this.getToken()) {
+    callback(true, null, null);
+  } else {
+    var self = this;
+    var options = {
+      method:'GET',
+      endpoint:'users/me'
+    };
+    this.request(options, function(err, data) {
       if (err) {
         if (self.logging) {
-        console.log('error trying to log user in');
+          console.log('error trying to log user in');
         }
         if (typeof(callback) === 'function') {
-        callback(err, data, null);
+          callback(err, data, null);
         }
       } else {
         var options = {
-          client: self,
-          data: data.entities[0]
+          client:self,
+          data:data.entities[0]
         };
         var user = new Usergrid.Entity(options);
         if (typeof(callback) === 'function') {
-        callback(err, data, user);
+          callback(err, data, user);
         }
       }
-      });
-    }
-    };
-
-    /*
-    *  A public method to test if a user is logged in - does not guarantee that the token is still valid,
-    *  but rather that one exists
-    *
-    *  @method isLoggedIn
-    *  @public
-    *  @return {boolean} Returns true the user is logged in (has token and uuid), false if not
-    */
-    Usergrid.Client.prototype.isLoggedIn = function() {
-      if (this.getToken() && this.getToken() != 'null') {
-      return true;
-    }
-    return false;
-    };
-
-    /*
-    *  A public method to log out an app user - clears all user fields from client
-    *
-    *  @method logout
-    *  @public
-    *  @return none
-    */
-    Usergrid.Client.prototype.logout = function() {
-    this.setToken(null);
-    };
-
-    /*
-    *  A private method to build the curl call to display on the command line
-    *
-    *  @method buildCurlCall
-    *  @private
-    *  @param {object} options
-    *  @return {string} curl
-    */
-    Usergrid.Client.prototype.buildCurlCall = function(options) {
-    var curl = 'curl';
-    var method = (options.method || 'GET').toUpperCase();
-    var body = options.body || {};
-    var uri = options.uri;
-
-    //curl - add the method to the command (no need to add anything for GET)
-      if (method === 'POST') {
-      curl += ' -X POST';
-      } else if (method === 'PUT') {
-      curl += ' -X PUT';
-      } else if (method === 'DELETE') {
-      curl += ' -X DELETE';
-      } else {
-      curl += ' -X GET';
-      }
-
-    //curl - append the path
-    curl += ' ' + uri;
-
-    //curl - add the body
-    if("undefined"!== typeof window){body = JSON.stringify(body);}//only in node module
-    if (body !== '"{}"' && method !== 'GET' && method !== 'DELETE') {
-      //curl - add in the json obj
-      curl += " -d '" + body + "'";
-    }
+    });
+  }
+};
 
-    //log the curl command to the console
-    console.log(curl);
+/*
+ *  A public method to test if a user is logged in - does not guarantee that the token is still valid,
+ *  but rather that one exists
+ *
+ *  @method isLoggedIn
+ *  @public
+ *  @return {boolean} Returns true the user is logged in (has token and uuid), false if not
+ */
+Usergrid.Client.prototype.isLoggedIn = function () {
+  if (this.getToken() && this.getToken() != 'null') {
+    return true;
+  }
+  return false;
+};
 
-    return curl;
-    }
+/*
+ *  A public method to log out an app user - clears all user fields from client
+ *
+ *  @method logout
+ *  @public
+ *  @return none
+ */
+Usergrid.Client.prototype.logout = function () {
+  this.setToken(null);
+};
 
-    Usergrid.Client.prototype.getDisplayImage = function (email, picture, size) {
-    try {
-      if (picture) {
+/*
+ *  A private method to build the curl call to display on the command line
+ *
+ *  @method buildCurlCall
+ *  @private
+ *  @param {object} options
+ *  @return {string} curl
+ */
+Usergrid.Client.prototype.buildCurlCall = function (options) {
+  var curl = 'curl';
+  var method = (options.method || 'GET').toUpperCase();
+  var body = options.body || {};
+  var uri = options.uri;
+
+  //curl - add the method to the command (no need to add anything for GET)
+  if (method === 'POST') {
+    curl += ' -X POST';
+  } else if (method === 'PUT') {
+    curl += ' -X PUT';
+  } else if (method === 'DELETE') {
+    curl += ' -X DELETE';
+  } else {
+    curl += ' -X GET';
+  }
+
+  //curl - append the path
+  curl += ' ' + uri;
+
+  //curl - add the body
+  if("undefined"!== typeof window){body = JSON.stringify(body);}//only in node module
+  if (body !== '"{}"' && method !== 'GET' && method !== 'DELETE') {
+    //curl - add in the json obj
+    curl += " -d '" + body + "'";
+  }
+
+  //log the curl command to the console
+  console.log(curl);
+
+  return curl;
+}
+
+Usergrid.Client.prototype.getDisplayImage = function (email, picture, size) {
+  try {
+    if (picture) {
       return picture;
-      }
-      var size = size || 50;
-      if (email.length) {
+    }
+    var size = size || 50;
+    if (email.length) {
       return 'https://secure.gravatar.com/avatar/' + MD5(email) + '?s=' + size + encodeURI("&d=https://apigee.com/usergrid/images/user_profile.png");
-      } else {
-      return 'https://apigee.com/usergrid/images/user_profile.png';
-      }
-    } catch(e) {
+    } else {
       return 'https://apigee.com/usergrid/images/user_profile.png';
     }
-    }
+  } catch(e) {
+    return 'https://apigee.com/usergrid/images/user_profile.png';
+  }
+}
 
-    /*
-    *  A class to Model a Usergrid Entity.
-    *  Set the type and uuid of entity in the 'data' json object
-    *
-    *  @constructor
-    *  @param {object} options {client:client, data:{'type':'collection_type', uuid:'uuid', 'key':'value'}}
-    */
-    Usergrid.Entity = function(options) {
-    if (options) {
-      this._data = options.data || {};
-      this._client = options.client || {};
-    }
-    };
+/*
+ *  A class to Model a Usergrid Entity.
+ *  Set the type and uuid of entity in the 'data' json object
+ *
+ *  @constructor
+ *  @param {object} options {client:client, data:{'type':'collection_type', uuid:'uuid', 'key':'value'}}
+ */
+Usergrid.Entity = function(options) {
+  if (options) {
+    this._data = options.data || {};
+    this._client = options.client || {};
+  }
+};
 
-    /*
-     *  returns a serialized version of the entity object
-     *
-     *  Note: use the client.restoreEntity() function to restore
-     *
-     *  @method serialize
-     *  @return {string} data
-     */
-    Usergrid.Entity.prototype.serialize = function() {
-    return JSON.stringify(this._data);
-    };
+/*
+ *  returns a serialized version of the entity object
+ *
+ *  Note: use the client.restoreEntity() function to restore
+ *
+ *  @method serialize
+ *  @return {string} data
+ */
+Usergrid.Entity.prototype.serialize = function () {
+  return JSON.stringify(this._data);
+};
 
-    /*
-    *  gets a specific field or the entire data object. If null or no argument
-    *  passed, will return all data, else, will return a specific field
-    *
-    *  @method get
-    *  @param {string} field
-    *  @return {string} || {object} data
-    */
-    Usergrid.Entity.prototype.get = function(field) {
-    if (field) {
-      return this._data[field];
-    } else {
-      return this._data;
-    }
-    };
+/*
+ *  gets a specific field or the entire data object. If null or no argument
+ *  passed, will return all data, else, will return a specific field
+ *
+ *  @method get
+ *  @param {string} field
+ *  @return {string} || {object} data
+ */
+Usergrid.Entity.prototype.get = function (field) {
+  if (field) {
+    return this._data[field];
+  } else {
+    return this._data;
+  }
+};
 
-    /*
-    *  adds a specific key value pair or object to the Entity's data
-    *  is additive - will not overwrite existing values unless they
-    *  are explicitly specified
-    *
-    *  @method set
-    *  @param {string} key || {object}
-    *  @param {string} value
-    *  @return none
-    */
-    Usergrid.Entity.prototype.set = function(key, value) {
-    if (typeof key === 'object') {
-      for (var field in key) {
+/*
+ *  adds a specific key value pair or object to the Entity's data
+ *  is additive - will not overwrite existing values unless they
+ *  are explicitly specified
+ *
+ *  @method set
+ *  @param {string} key || {object}
+ *  @param {string} value
+ *  @return none
+ */
+Usergrid.Entity.prototype.set = function (key, value) {
+  if (typeof key === 'object') {
+    for(var field in key) {
       this._data[field] = key[field];
-      }
-    } else if (typeof key === 'string') {
-      if (value === null) {
+    }
+  } else if (typeof key === 'string') {
+    if (value === null) {
       delete this._data[key];
-      } else {
-      this._data[key] = value;
-      }
     } else {
-      this._data = {};
-    }
-    };
-
-    /*
-    *  Saves the entity back to the database
-    *
-    *  @method save
-    *  @public
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Entity.prototype.save = function(callback) {
-    var type = this.get('type');
-    var method = 'POST';
-    if (isUUID(this.get('uuid'))) {
-      method = 'PUT';
-      type += '/' + this.get('uuid');
+      this._data[key] = value;
     }
+  } else {
+    this._data = {};
+  }
+};
 
-    //update the entity
-    var self = this;
-    var data = {};
-    var entityData = this.get();
-    //remove system specific properties
-    for (var item in entityData) {
-      if (item === 'metadata' || item === 'created' || item === 'modified' ||
-        item === 'type' || item === 'activated' || item === 'uuid') {
-        continue;
-      }
-      data[item] = entityData[item];
-    }
-      var options = {
-      method: method,
-      endpoint: type,
-      body: data
-    };
-    //save the entity first
-      this._client.request(options, function(err, retdata) {
-      if (err && self._client.logging) {
+/*
+ *  Saves the entity back to the database
+ *
+ *  @method save
+ *  @public
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Entity.prototype.save = function (callback) {
+  var type = this.get('type');
+  var method = 'POST';
+  if (isUUID(this.get('uuid'))) {
+    method = 'PUT';
+    type += '/' + this.get('uuid');
+  }
+
+  //update the entity
+  var self = this;
+  var data = {};
+  var entityData = this.get();
+    var password = this.get('password');
+    var oldpassword = this.get('oldpassword');
+    var newpassword = this.get('newpassword');
+  //remove system specific properties
+  for (var item in entityData) {
+    if (item === 'metadata' || item === 'created' || item === 'modified' ||
+          item === 'oldpassword' || item === 'newpassword' || //old and new pw not added to data
+      item === 'type' || item === 'activated' || item === 'uuid') {
+      continue;
+    }
+    data[item] = entityData[item];
+  }
+  var options =  {
+    method:method,
+    endpoint:type,
+    body:data
+  };
+  //save the entity first
+  this._client.request(options, function (err, retdata) {
+      //clear out pw info if present
+      self.set('password', null);
+      self.set('oldpassword', null);
+      self.set('newpassword', null);
+    if (err && self._client.logging) {
       console.log('could not save entity');
       if (typeof(callback) === 'function') {
         return callback(err, retdata, self);
       }
-      } else {
+    } else {
       if (retdata.entities) {
         if (retdata.entities.length) {
-        var entity = retdata.entities[0];
-        self.set(entity);
-        var path = retdata.path;
-        //for connections, API returns type
-        while (path.substring(0, 1) === "/") {
-          path = path.substring(1);
-        }
-        self.set('type', path);
+          var entity = retdata.entities[0];
+          self.set(entity);
+          var path = retdata.path;
+          //for connections, API returns type
+          while (path.substring(0, 1) === "/") {
+            path = path.substring(1);
+          }
+          self.set('type', path);
         }
       }
       //if this is a user, update the password if it has been specified;
-      var needPasswordChange = ((self.get('type') === 'user' || self.get('type') === 'users') && entityData.oldpassword && entityData.newpassword);
+        var needPasswordChange = ((self.get('type') === 'user' || self.get('type') === 'users') && oldpassword && newpassword);
       if (needPasswordChange) {
         //Note: we have a ticket in to change PUT calls to /users to accept the password change
         //      once that is done, we will remove this call and merge it all into one
         var pwdata = {};
-        pwdata.oldpassword = entityData.oldpassword;
-        pwdata.newpassword = entityData.newpassword;
+          pwdata.oldpassword = oldpassword;
+          pwdata.newpassword = newpassword;
         var options = {
-          method: 'PUT',
-          endpoint: type + '/password',
-          body: pwdata
-        }
-        self._client.request(options, function(err, data) {
-        if (err && self._client.logging) {
-          console.log('could not update user');
-        }
-        //remove old and new password fields so they don't end up as part of the entity object
-        self.set('oldpassword', null);
-        self.set('newpassword', null);
-        if (typeof(callback) === 'function') {
-          callback(err, data, self);
+          method:'PUT',
+          endpoint:type+'/password',
+          body:pwdata
         }
+        self._client.request(options, function (err, data) {
+          if (err && self._client.logging) {
+            console.log('could not update user');
+          }
+          //remove old and new password fields so they don't end up as part of the entity object
+          self.set('oldpassword', null);
+          self.set('newpassword', null);
+          if (typeof(callback) === 'function') {
+            callback(err, data, self);
+          }
         });
       } else if (typeof(callback) === 'function') {
         callback(err, retdata, self);
       }
-      }
-    });
-    };
+    }
+  });
+};
 
-    /*
-    *  refreshes the entity by making a GET call back to the database
-    *
-    *  @method fetch
-    *  @public
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Entity.prototype.fetch = function(callback) {
-    var type = this.get('type');
-    var self = this;
-    //Check for an entity type, then if a uuid is available, use that, otherwise, use the name
-    try {
-      if (type === undefined) {
+/*
+ *  refreshes the entity by making a GET call back to the database
+ *
+ *  @method fetch
+ *  @public
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Entity.prototype.fetch = function (callback) {
+  var type = this.get('type');
+  var self = this;
+
+  //Check for an entity type, then if a uuid is available, use that, otherwise, use the name
+  try {
+    if (type === undefined) {
       throw 'cannot fetch entity, no entity type specified'
-      } else if (this.get('uuid')) {
+    } else if (this.get('uuid')) {
       type += '/' + this.get('uuid');
-      } else if (type === 'users' && this.get('username')) {
+    } else if (type === 'users' && this.get('username')) {
       type += '/' + this.get('username');
-      } else if (this.get('name')) {
+    } else if (this.get('name')) {
       type += '/' + encodeURIComponent(this.get('name'));
-      } else if (typeof(callback) === 'function') {
+    } else if (typeof(callback) === 'function') {
       throw 'no_name_specified';
-      }
-    } catch (e) {
-      if (self._client.logging) {
+    }
+  } catch (e) {
+    if (self._client.logging) {
       console.log(e);
-      }
-      return callback(true, {
-      error: e
-      }, self);
     }
-    var options = {
-      method: 'GET',
-      endpoint: type
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+    return callback(true, {
+      error: e
+    }, self);
+  }
+  var options = {
+    method:'GET',
+    endpoint:type
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('could not get entity');
-      } else {
+    } else {
       if (data.user) {
         self.set(data.user);
         self._json = JSON.stringify(data.user, null, 2);
       } else if (data.entities) {
         if (data.entities.length) {
-        var entity = data.entities[0];
-        self.set(entity);
+          var entity = data.entities[0];
+          self.set(entity);
         }
       }
-      }
-      if (typeof(callback) === 'function') {
+    }
+    if (typeof(callback) === 'function') {
       callback(err, data, self);
-      }
-    });
-    };
+    }
+  });
+};
 
-    /*
-    *  deletes the entity from the database - will only delete
-    *  if the object has a valid uuid
-    *
-    *  @method destroy
-    *  @public
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    *
-    */
-    Usergrid.Entity.prototype.destroy = function (callback) {
-    var self = this;
-    var type = this.get('type');
-    if (isUUID(this.get('uuid'))) {
-      type += '/' + this.get('uuid');
-    } else {
-      if (typeof(callback) === 'function') {
+/*
+ *  deletes the entity from the database - will only delete
+ *  if the object has a valid uuid
+ *
+ *  @method destroy
+ *  @public
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ *
+ */
+Usergrid.Entity.prototype.destroy = function (callback) {
+  var self = this;
+  var type = this.get('type');
+  if (isUUID(this.get('uuid'))) {
+    type += '/' + this.get('uuid');
+  } else {
+    if (typeof(callback) === 'function') {
       var error = 'Error trying to delete object - no uuid specified.';
       if (self._client.logging) {
         console.log(error);
       }
       callback(true, error);
-      }
     }
-    var options = {
-      method: 'DELETE',
-      endpoint: type
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+  }
+  var options = {
+    method:'DELETE',
+    endpoint:type
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('entity could not be deleted');
-      } else {
+    } else {
       self.set(null);
-      }
-      if (typeof(callback) === 'function') {
+    }
+    if (typeof(callback) === 'function') {
       callback(err, data);
-      }
-    });
-    };
-
-    /*
-    *  connects one entity to another
-    *
-    *  @method connect
-    *  @public
-    *  @param {string} connection
-    *  @param {object} entity
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    *
-    */
-    Usergrid.Entity.prototype.connect = function(connection, entity, callback) {
-
-    var self = this;
+    }
+  });
+};
 
-    var error;
-    //connectee info
-    var connecteeType = entity.get('type');
-    var connectee = this.getEntityId(entity);
-    if (!connectee) {
-      if (typeof(callback) === 'function') {
+/*
+ *  connects one entity to another
+ *
+ *  @method connect
+ *  @public
+ *  @param {string} connection
+ *  @param {object} entity
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ *
+ */
+Usergrid.Entity.prototype.connect = function (connection, entity, callback) {
+
+  var self = this;
+
+  var error;
+  //connectee info
+  var connecteeType = entity.get('type');
+  var connectee = this.getEntityId(entity);
+  if (!connectee) {
+    if (typeof(callback) === 'function') {
       error = 'Error trying to delete object - no uuid specified.';
       if (self._client.logging) {
         console.log(error);
       }
       callback(true, error);
-      }
-      return;
     }
+    return;
+  }
 
-    //connector info
-    var connectorType = this.get('type');
-    var connector = this.getEntityId(this);
-    if (!connector) {
-      if (typeof(callback) === 'function') {
+  //connector info
+  var connectorType = this.get('type');
+  var connector = this.getEntityId(this);
+  if (!connector) {
+    if (typeof(callback) === 'function') {
       error = 'Error in connect - no uuid specified.';
       if (self._client.logging) {
         console.log(error);
       }
       callback(true, error);
-      }
-      return;
     }
+    return;
+  }
 
-    var endpoint = connectorType + '/' + connector + '/' + connection + '/' + connecteeType + '/' + connectee;
-    var options = {
-      method: 'POST',
-      endpoint: endpoint
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+  var endpoint = connectorType + '/' + connector + '/' + connection + '/' + connecteeType + '/' + connectee;
+  var options = {
+    method:'POST',
+    endpoint:endpoint
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('entity could not be connected');
-      }
-      if (typeof(callback) === 'function') {
+    }
+    if (typeof(callback) === 'function') {
       callback(err, data);
-      }
-    });
-    };
+    }
+  });
+};
 
-    /*
-    *  returns a unique identifier for an entity
-    *
-    *  @method connect
-    *  @public
-    *  @param {object} entity
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    *
-    */
-    Usergrid.Entity.prototype.getEntityId = function(entity) {
-    var id = false;
-    if (isUUID(entity.get('uuid'))) {
-      id = entity.get('uuid');
-    } else {
-      if (type === 'users') {
+/*
+ *  returns a unique identifier for an entity
+ *
+ *  @method connect
+ *  @public
+ *  @param {object} entity
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ *
+ */
+Usergrid.Entity.prototype.getEntityId = function (entity) {
+  var id = false;
+  if (isUUID(entity.get('uuid'))) {
+    id = entity.get('uuid');
+  } else {
+    if (type === 'users') {
       id = entity.get('username');
-      } else if (entity.get('name')) {
+    } else if (entity.get('name')) {
       id = entity.get('name');
-      }
     }
-    return id;
-    };
-
-    /*
-    *  gets an entities connections
-    *
-    *  @method getConnections
-    *  @public
-    *  @param {string} connection
-    *  @param {object} entity
-    *  @param {function} callback
-    *  @return {callback} callback(err, data, connections)
-    *
-    */
-    Usergrid.Entity.prototype.getConnections = function(connection, callback) {
+  }
+  return id;
+};
 
-    var self = this;
-
-    //connector info
-    var connectorType = this.get('type');
-    var connector = this.getEntityId(this);
-    if (!connector) {
-      if (typeof(callback) === 'function') {
+/*
+ *  gets an entities connections
+ *
+ *  @method getConnections
+ *  @public
+ *  @param {string} connection
+ *  @param {object} entity
+ *  @param {function} callback
+ *  @return {callback} callback(err, data, connections)
+ *
+ */
+Usergrid.Entity.prototype.getConnections = function (connection, callback) {
+
+  var self = this;
+
+  //connector info
+  var connectorType = this.get('type');
+  var connector = this.getEntityId(this);
+  if (!connector) {
+    if (typeof(callback) === 'function') {
       var error = 'Error in getConnections - no uuid specified.';
       if (self._client.logging) {
         console.log(error);
       }
       callback(true, error);
-      }
-      return;
     }
+    return;
+  }
 
-    var endpoint = connectorType + '/' + connector + '/' + connection + '/';
-    var options = {
-      method: 'GET',
-      endpoint: endpoint
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+  var endpoint = connectorType + '/' + connector + '/' + connection + '/';
+  var options = {
+    method:'GET',
+    endpoint:endpoint
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('entity could not be connected');
-      }
+    }
 
-      self[connection] = {};
+    self[connection] = {};
 
-      var length = data.entities.length;
-      for (var i = 0; i < length; i++) {
-        if (data.entities[i].type === 'user') {
+    var length = data.entities.length;
+    for (var i = 0; i < length; i++) {
+      if (data.entities[i].type === 'user'){
         self[connection][data.entities[i].username] = data.entities[i];
       } else {
         self[connection][data.entities[i].name] = data.entities[i]
       }
-      }
+    }
 
-      if (typeof(callback) === 'function') {
+    if (typeof(callback) === 'function') {
       callback(err, data, data.entities);
-      }
-    });
+    }
+  });
 
-    };
+};
 
-    Usergrid.Entity.prototype.getGroups = function(callback) {
+Usergrid.Entity.prototype.getGroups = function (callback) {
 
-    var self = this;
+  var self = this;
 
-      var endpoint = 'users' + '/' + this.get('uuid') + '/groups';
-    var options = {
-      method: 'GET',
-      endpoint: endpoint
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+  var endpoint = 'users' + '/' + this.get('uuid') + '/groups' ;
+  var options = {
+    method:'GET',
+    endpoint:endpoint
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('entity could not be connected');
-      }
+    }
 
-      self.groups = data.entities;
+    self.groups = data.entities;
 
-      if (typeof(callback) === 'function') {
+    if (typeof(callback) === 'function') {
       callback(err, data, data.entities);
-      }
-    });
+    }
+  });
 
-    };
+};
 
-    Usergrid.Entity.prototype.getActivities = function(callback) {
+Usergrid.Entity.prototype.getActivities = function (callback) {
 
-    var self = this;
+  var self = this;
 
-      var endpoint = this.get('type') + '/' + this.get('uuid') + '/activities';
-    var options = {
-      method: 'GET',
-      endpoint: endpoint
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+  var endpoint = this.get('type') + '/' + this.get('uuid') + '/activities' ;
+  var options = {
+    method:'GET',
+    endpoint:endpoint
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('entity could not be connected');
-      }
+    }
 
-      for (var entity in data.entities) {
+    for (var entity in data.entities) {
       data.entities[entity].createdDate = (new Date(data.entities[entity].created)).toUTCString();
-      }
+    }
 
-      self.activities = data.entities;
+    self.activities = data.entities;
 
-      if (typeof(callback) === 'function') {
+    if (typeof(callback) === 'function') {
       callback(err, data, data.entities);
-      }
-    });
+    }
+  });
 
-    };
+};
 
-    Usergrid.Entity.prototype.getFollowing = function(callback) {
+Usergrid.Entity.prototype.getFollowing = function (callback) {
 
-    var self = this;
+  var self = this;
 
-      var endpoint = 'users' + '/' + this.get('uuid') + '/following';
-    var options = {
-      method: 'GET',
-      endpoint: endpoint
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+  var endpoint = 'users' + '/' + this.get('uuid') + '/following' ;
+  var options = {
+    method:'GET',
+    endpoint:endpoint
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('could not get user following');
-      }
+    }
 
-      for (var entity in data.entities) {
+    for (var entity in data.entities) {
       data.entities[entity].createdDate = (new Date(data.entities[entity].created)).toUTCString();
       var image = self._client.getDisplayImage(data.entities[entity].email, data.entities[entity].picture);
-        data.entities[entity]._portal_image_icon = image;
-      }
+      data.entities[entity]._portal_image_icon =  image;
+    }
 
-      self.following = data.entities;
+    self.following = data.entities;
 
-      if (typeof(callback) === 'function') {
+    if (typeof(callback) === 'function') {
       callback(err, data, data.entities);
-      }
-    });
+    }
+  });
 
-    };
+};
 
 
-    Usergrid.Entity.prototype.getFollowers = function(callback) {
+Usergrid.Entity.prototype.getFollowers = function (callback) {
 
-    var self = this;
+  var self = this;
 
-      var endpoint = 'users' + '/' + this.get('uuid') + '/followers';
-    var options = {
-      method: 'GET',
-      endpoint: endpoint
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+  var endpoint = 'users' + '/' + this.get('uuid') + '/followers' ;
+  var options = {
+    method:'GET',
+    endpoint:endpoint
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('could not get user followers');
-      }
+    }
 
-      for (var entity in data.entities) {
+    for (var entity in data.entities) {
       data.entities[entity].createdDate = (new Date(data.entities[entity].created)).toUTCString();
       var image = self._client.getDisplayImage(data.entities[entity].email, data.entities[entity].picture);
-        data.entities[entity]._portal_image_icon = image;
-      }
+      data.entities[entity]._portal_image_icon =  image;
+    }
 
-      self.followers = data.entities;
+    self.followers = data.entities;
 
-      if (typeof(callback) === 'function') {
+    if (typeof(callback) === 'function') {
       callback(err, data, data.entities);
-      }
-    });
+    }
+  });
 
-    };
+};
 
-    Usergrid.Entity.prototype.getRoles = function(callback) {
+Usergrid.Entity.prototype.getRoles = function (callback) {
 
-    var self = this;
+  var self = this;
 
-      var endpoint = this.get('type') + '/' + this.get('uuid') + '/roles';
-    var options = {
-      method: 'GET',
-      endpoint: endpoint
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+  var endpoint = this.get('type') + '/' + this.get('uuid') + '/roles' ;
+  var options = {
+    method:'GET',
+    endpoint:endpoint
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('could not get user roles');
-      }
+    }
 
-      self.roles = data.entities;
+    self.roles = data.entities;
 
-      if (typeof(callback) === 'function') {
+    if (typeof(callback) === 'function') {
       callback(err, data, data.entities);
-      }
-    });
+    }
+  });
 
-    };
+};
 
-    Usergrid.Entity.prototype.getPermissions = function(callback) {
+Usergrid.Entity.prototype.getPermissions = function (callback) {
 
-    var self = this;
+  var self = this;
 
-      var endpoint = this.get('type') + '/' + this.get('uuid') + '/permissions';
-    var options = {
-      method: 'GET',
-      endpoint: endpoint
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+  var endpoint = this.get('type') + '/' + this.get('uuid') + '/permissions' ;
+  var options = {
+    method:'GET',
+    endpoint:endpoint
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('could not get user permissions');
-      }
+    }
 
-      var permissions = [];
-      if (data.data) {
+    var permissions = [];
+    if (data.data) {
       var perms = data.data;
       var count = 0;
 
@@ -1587,8 +1451,8 @@
         var path_part = parts[0];
 
         if (parts.length > 1) {
-        ops_part = parts[0];
-        path_part = parts[1];
+          ops_part = parts[0];
+          path_part = parts[1];
         }
 
         ops_part.replace("*", "get,post,put,delete")
@@ -1599,7 +1463,7 @@
         ops_object.put = 'no';
         ops_object.delete = 'no';
         for (var j in ops) {
-        ops_object[ops[j]] = 'yes';
+          ops_object[ops[j]] = 'yes';
         }
 
         permissions.push({
@@ -1608,158 +1472,158 @@
           perm: perm
         });
       }
-      }
+    }
 
-      self.permissions = permissions;
+    self.permissions = permissions;
 
-      if (typeof(callback) === 'function') {
+    if (typeof(callback) === 'function') {
       callback(err, data, data.entities);
-      }
-    });
-
-    };
-
-    /*
-    *  disconnects one entity from another
-    *
-    *  @method disconnect
-    *  @public
-    *  @param {string} connection
-    *  @param {object} entity
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    *
-    */
-    Usergrid.Entity.prototype.disconnect = function(connection, entity, callback) {
+    }
+  });
 
-    var self = this;
+};
 
-    var error;
-    //connectee info
-    var connecteeType = entity.get('type');
-    var connectee = this.getEntityId(entity);
-    if (!connectee) {
-      if (typeof(callback) === 'function') {
+/*
+ *  disconnects one entity from another
+ *
+ *  @method disconnect
+ *  @public
+ *  @param {string} connection
+ *  @param {object} entity
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ *
+ */
+Usergrid.Entity.prototype.disconnect = function (connection, entity, callback) {
+
+  var self = this;
+
+  var error;
+  //connectee info
+  var connecteeType = entity.get('type');
+  var connectee = this.getEntityId(entity);
+  if (!connectee) {
+    if (typeof(callback) === 'function') {
       error = 'Error trying to delete object - no uuid specified.';
       if (self._client.logging) {
         console.log(error);
       }
       callback(true, error);
-      }
-      return;
     }
+    return;
+  }
 
-    //connector info
-    var connectorType = this.get('type');
-    var connector = this.getEntityId(this);
-    if (!connector) {
-      if (typeof(callback) === 'function') {
+  //connector info
+  var connectorType = this.get('type');
+  var connector = this.getEntityId(this);
+  if (!connector) {
+    if (typeof(callback) === 'function') {
       error = 'Error in connect - no uuid specified.';
       if (self._client.logging) {
         console.log(error);
       }
       callback(true, error);
-      }
-      return;
     }
+    return;
+  }
 
-    var endpoint = connectorType + '/' + connector + '/' + connection + '/' + connecteeType + '/' + connectee;
-    var options = {
-      method: 'DELETE',
-      endpoint: endpoint
-    };
-      this._client.request(options, function(err, data) {
-      if (err && self._client.logging) {
+  var endpoint = connectorType + '/' + connector + '/' + connection + '/' + connecteeType + '/' + connectee;
+  var options = {
+    method:'DELETE',
+    endpoint:endpoint
+  };
+  this._client.request(options, function (err, data) {
+    if (err && self._client.logging) {
       console.log('entity could not be disconnected');
-      }
-      if (typeof(callback) === 'function') {
+    }
+    if (typeof(callback) === 'function') {
       callback(err, data);
-      }
-    });
-    };
+    }
+  });
+};
+
+/*
+ *  The Collection class models Usergrid Collections.  It essentially
+ *  acts as a container for holding Entity objects, while providing
+ *  additional funcitonality such as paging, and saving
+ *
+ *  @constructor
+ *  @param {string} options - configuration object
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Collection = function(options, callback) {
+
+  if (options) {
+    this._client = options.client;
+    this._type = options.type;
+    this.qs = options.qs || {};
+
+    //iteration
+    this._list = options.list || [];
+    this._iterator = options.iterator || -1; //first thing we do is increment, so set to -1
 
-    /*
-    *  The Collection class models Usergrid Collections.  It essentially
-    *  acts as a container for holding Entity objects, while providing
-    *  additional funcitonality such as paging, and saving
-    *
-    *  @constructor
-    *  @param {string} options - configuration object
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Collection = function(options, callback) {
-
-    if (options) {
-      this._client = options.client;
-      this._type = options.type;
-      this.qs = options.qs || {};
-
-      //iteration
-      this._list = options.list || [];
-      this._iterator = options.iterator || -1; //first thing we do is increment, so set to -1
-
-      //paging
-      this._previous = options.previous || [];
-      this._next = options.next || null;
-      this._cursor = options.cursor || null;
-
-      //restore entities if available
-      if (options.list) {
+    //paging
+    this._previous = options.previous || [];
+    this._next = options.next || null;
+    this._cursor = options.cursor || null;
+
+    //restore entities if available
+    if (options.list) {
       var count = options.list.length;
-        for (var i = 0; i < count; i++) {
+      for(var i=0;i<count;i++){
         //make new entity with
         var entity = this._client.restoreEntity(options.list[i]);
         this._list[i] = entity;
       }
-      }
     }
-    if (callback) {
-      //populate the collection
-      this.fetch(callback);
-    }
-
-    };
+  }
+  if (callback) {
+    //populate the collection
+    this.fetch(callback);
+  }
 
+};
 
-    /*
-     *  gets the data from the collection object for serialization
-     *
-     *  @method serialize
-     *  @return {object} data
-     */
-    Usergrid.Collection.prototype.serialize = function() {
-
-    //pull out the state from this object and return it
-    var data = {}
-    data.type = this._type;
-    data.qs = this.qs;
-    data.iterator = this._iterator;
-    data.previous = this._previous;
-    data.next = this._next;
-    data.cursor = this._cursor;
-
-    this.resetEntityPointer();
-      var i = 0;
-    data.list = [];
-      while (this.hasNextEntity()) {
-      var entity = this.getNextEntity();
-      data.list[i] = entity.serialize();
-      i++;
-    }
-
-    data = JSON.stringify(data);
-    return data;
-    };
 
-    Usergrid.Collection.prototype.addCollection = function(collectionName, options, callback) {
-    self = this;
-    options.client = this._client;
-    var collection = new Usergrid.Collection(options, function(err, data) {
-      if (typeof(callback) === 'function') {
+/*
+ *  gets the data from the collection object for serialization
+ *
+ *  @method serialize
+ *  @return {object} data
+ */
+Usergrid.Collection.prototype.serialize = function () {
+
+  //pull out the state from this object and return it
+  var data = {}
+  data.type = this._type;
+  data.qs = this.qs;
+  data.iterator = this._iterator;
+  data.previous = this._previous;
+  data.next = this._next;
+  data.cursor = this._cursor;
+
+  this.resetEntityPointer();
+  var i=0;
+  data.list = [];
+  while(this.hasNextEntity()) {
+    var entity = this.getNextEntity();
+    data.list[i] = entity.serialize();
+    i++;
+  }
+
+  data = JSON.stringify(data);
+  return data;
+};
+
+Usergrid.Collection.prototype.addCollection = function (collectionName, options, callback) {
+  self = this;
+  options.client = this._client;
+  var collection = new Usergrid.Collection(options, function(err, data) {
+    if (typeof(callback) === 'function') {
 
       collection.resetEntityPointer();
-        while (collection.hasNextEntity()) {
+      while(collection.hasNextEntity()) {
         var user = collection.getNextEntity();
         var email = user.get('email');
         var image = self._client.getDisplayImage(user.get('email'), user.get('picture'));
@@ -1768,36 +1632,36 @@
 
       self[collectionName] = collection;
       callback(err, collection);
-      }
-    });
-    };
-
-    /*
-    *  Populates the collection from the server
-    *
-    *  @method fetch
-    *  @param {function} callback
-    *  @return {callback} callback(err, data)
-    */
-    Usergrid.Collection.prototype.fetch = function(callback) {
-    var self = this;
-    var qs = this.qs;
+    }
+  });
+};
 
-    //add in the cursor if one is available
-    if (this._cursor) {
-      qs.cursor = this._cursor;
+/*
+ *  Populates the collection from the server
+ *
+ *  @method fetch
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ */
+Usergrid.Collection.prototype.fetch = function (callback) {
+  var self = this;
+  var qs = this.qs;
+
+  //add in the cursor if one is available
+  if (this._cursor) {
+    qs.cursor = this._cursor;
+  } else {
+    delete qs.cursor;
+  }
+  var options = {
+    method:'GET',
+    endpoint:this._type,
+    qs:this.qs
+  };
+  this._client.request(options, function (err, data) {
+    if(err && self._client.logging) {
+      console.log('error getting collection');
     } else {
-      delete qs.cursor;
-    }
-    var options = {
-      method: 'GET',
-      endpoint: this._type,
-      qs: this.qs
-    };
-      this._client.request(opt

<TRUNCATED>

Mime
View raw message