usergrid-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mru...@apache.org
Subject [2/2] usergrid-nodejs git commit: Initial commit of Usergrid Node.js SDK into its own repo
Date Fri, 02 Sep 2016 16:16:21 GMT
Initial commit of Usergrid Node.js SDK into its own repo


Project: http://git-wip-us.apache.org/repos/asf/usergrid-nodejs/repo
Commit: http://git-wip-us.apache.org/repos/asf/usergrid-nodejs/commit/7b92555b
Tree: http://git-wip-us.apache.org/repos/asf/usergrid-nodejs/tree/7b92555b
Diff: http://git-wip-us.apache.org/repos/asf/usergrid-nodejs/diff/7b92555b

Branch: refs/heads/master
Commit: 7b92555b58c29a30e1e2f1dc638b50b6407539a7
Parents: 
Author: Michael Russo <mrusso@apigee.com>
Authored: Fri Sep 2 09:16:01 2016 -0700
Committer: Michael Russo <mrusso@apigee.com>
Committed: Fri Sep 2 09:16:01 2016 -0700

----------------------------------------------------------------------
 .gitignore         |    2 +
 LICENSE            |   20 +
 changelog.md       |   43 +
 lib/usergrid.js    | 2584 +++++++++++++++++++++++++++++++++++++++++++++++
 package.json       |   43 +
 readme.md          |  720 +++++++++++++
 test.js            | 1077 ++++++++++++++++++++
 test/client.js     |  183 ++++
 test/collection.js |  259 +++++
 test/entity.js     |   59 ++
 10 files changed, 4990 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/usergrid-nodejs/blob/7b92555b/.gitignore
----------------------------------------------------------------------
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..c564040
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+.idea
+node_modules/
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/usergrid-nodejs/blob/7b92555b/LICENSE
----------------------------------------------------------------------
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..3a12e26
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Apigee Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

http://git-wip-us.apache.org/repos/asf/usergrid-nodejs/blob/7b92555b/changelog.md
----------------------------------------------------------------------
diff --git a/changelog.md b/changelog.md
new file mode 100755
index 0000000..c44ab04
--- /dev/null
+++ b/changelog.md
@@ -0,0 +1,43 @@
+##Change log
+
+
+###0.10.7
+- Fixed issue where token was appeneded even when no token was present
+- Updated tests
+
+
+###0.10.5
+
+- Added new class and methods for Groups
+- Added serialization / restore methods for entities and collections
+- Various bug fixes
+- Added function for getting user feed
+- Added function for creating user activities with an associated user entity
+- Added public facing helper method for signing up users
+
+###0.10.4
+
+- Added new functions for creating, getting, and deleting connections
+- Added test cases for said functions
+- Fixed change password error
+- Added getEntity method to get existing entity from server
+
+###0.10.3
+
+- Added set / get token methods to accomodate session storage
+- Added createUserActivity method to make creating activities for logged in user easier
+
+###0.10.2
+
+- Removed local caching of user object in client
+
+###0.10.1
+
+- Minor refactor of the SDK to bring congruity with the App services Javascript SDK
+
+###0.10.0
+- Complete refactor of the entire module
+
+- Added Mocha based test suite
+
+- Added full coverage of all sample code in the readme file

http://git-wip-us.apache.org/repos/asf/usergrid-nodejs/blob/7b92555b/lib/usergrid.js
----------------------------------------------------------------------
diff --git a/lib/usergrid.js b/lib/usergrid.js
new file mode 100755
index 0000000..b29dd3f
--- /dev/null
+++ b/lib/usergrid.js
@@ -0,0 +1,2584 @@
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You 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.
+//
+
+var inflection = require('inflection');
+var request = require('request');
+var Usergrid = {};
+Usergrid.USERGRID_SDK_VERSION = '0.10.07';
+
+//authentication type constants
+var AUTH_CLIENT_ID = 'CLIENT_ID';
+var AUTH_APP_USER = 'APP_USER';
+var AUTH_NONE = 'NONE';
+
+  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);
+    }
+
+    //authentication data
+    this.authType = options.authType || AUTH_NONE;
+    this.clientId = options.clientId;
+    this.clientSecret = options.clientSecret;
+    this.token = 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.  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');
+      }
+    }
+    var uri;
+    if (mQuery) {
+      uri = this.URI + '/' + endpoint;
+    } else {
+      uri = this.URI + '/' + orgName + '/' + appName + '/' + endpoint;
+    }
+
+    if (this.authType === AUTH_CLIENT_ID) {
+      qs['client_id'] = this.clientId;
+      qs['client_secret'] = this.clientSecret;
+    } else if (this.authType === AUTH_APP_USER && self.getToken()) {
+      qs['access_token'] = self.getToken();
+    }
+
+    if (this.logging) {
+      console.log('calling: ' + method + ' ' + uri);
+    }
+    this._start = new Date().getTime();
+    var callOptions = {
+      method: method,
+      uri: uri,
+      json: body,
+      qs: qs
+    };
+    request(callOptions, function (err, r, data) {
+
+      r.body = r.body || {};
+      data = data || {};
+
+      if (self.buildCurl) {
+        options.uri = r.request.uri.href;
+        self.buildCurlCall(options);
+      }
+      self._end = new Date().getTime();
+      if(r.statusCode === 200) {
+        if (self.logging) {
+          console.log('success (time: ' + self.calcTimeDiff() + '): ' + method + ' ' + uri);
+        }
+        callback(err, data);
+      } else {
+        err = true;
+        data.statusCode = r.statusCode;
+        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);
+          }
+          //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);
+          }
+        }
+      }
+    });
+  };
+  /*
+   *  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;
+   }
+
+  /*
+   *  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;
+    delete options.getOnExist;
+
+    var 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){
+          if (typeof(callback) === 'function') {
+            callback(err, group);
+          }
+        });
+      } 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.
+    /*
+    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
+    delete options.getOnExist;
+
+    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);
+          }
+        });
+      } 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) {
+    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);
+    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') {
+        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 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) {
+          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';
+    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"),
+        "image": {
+          "duration":0,
+          "height":80,
+          "url":user.get("picture"),
+          "width":80
+         },
+      },
+      "verb":"post",
+      "content":content };
+
+    this.createUserActivity(username, options, callback);
+
+  }
+
+  /*
+  *  A private method to get call timing of last call
+  */
+  Usergrid.Client.prototype.calcTimeDiff = function () {
+   var time = this._end - this._start;
+   return (time/1000).toFixed(2);
+  }
+
+  /*
+   *  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 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) {
+        localStorage.setItem(keyStore, value);
+      } else {
+        localStorage.removeItem(keyStore);
+      }
+    }
+  }
+
+  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;
+  }
+
+  /*
+   * 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);
+  }
+
+  /*
+  *
+  *  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) {
+        console.log('error trying to log user in');
+      } else {
+        var options = {
+          client:self,
+          data:data.user
+        }
+        user = new Usergrid.Entity(options);
+        self.setToken(data.access_token);
+        }
+      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) {
+        console.log('error trying to re-authenticate user');
+      } else {
+
+        //save the re-authed token and current email/username
+        self.setToken(response.access_token);
+
+      }
+      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 = {};
+      if (err && self.logging) {
+        console.log('error trying to full authenticate user');
+      } else {
+        var data = response.data;
+        self.setToken(data.token);
+        self.set('email', data.email);
+
+        //delete next block and corresponding function when iframes are refactored
+        localStorage.setItem('accessToken', data.token);
+        localStorage.setItem('userUUID', data.uuid);
+        localStorage.setItem('userEmail', data.email);
+        //end delete block
+
+
+        var userData = {
+          "username" : data.username,
+          "email" : data.email,
+          "name" : data.name,
+          "uuid" : data.uuid
+        }
+        var options = {
+          client:self,
+          data:userData
+        }
+        user = new Usergrid.Entity(options);
+
+        organizations = data.organizations;
+        var org = '';
+        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]];
+          self.set('orgName', org.name);
+        } catch(e) {
+          err = true;
+          if (self.logging) { console.log('error selecting org'); }
+        } //should always be an org
+
+        applications = self.parseApplicationsArray(org);
+        self.selectFirstApp(applications);
+
+        self.setObject('organizations', organizations);
+        self.setObject('applications', applications);
+
+      }
+      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:{
+        fb_access_token: facebookToken
+      }
+    };
+    this.request(options, function(err, data) {
+      var user = {};
+      if (err && self.logging) {
+        console.log('error trying to log user in');
+      } else {
+        var options = {
+          client: self,
+          data: data.user
+        }
+        user = new Usergrid.Entity(options);
+        self.setToken(data.access_token);
+      }
+      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) {
+        if (err) {
+          if (self.logging) {
+            console.log('error trying to log user in');
+          }
+          if (typeof(callback) === 'function') {
+            callback(err, data, null);
+          }
+        } else {
+          var options = {
+            client:self,
+            data:data.entities[0]
+          }
+          var user = new Usergrid.Entity(options);
+          if (typeof(callback) === 'function') {
+            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()) {
+      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
+    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) {
+        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) {
+      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 || {};
+    }
+  };
+
+  /*
+   *  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;
+    }
+  }
+
+  /*
+  *  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) {
+        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');
+    }
+
+    //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 {
+        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);
+          }
+        }
+        //if this is a user, update the password if it has been specified;
+        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 = 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);
+            }
+          });
+        } 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) {
+      throw 'cannot fetch entity, no entity type specified'
+    } else if (this.get('uuid')) {
+      type += '/' + this.get('uuid');
+    } else if (type === 'users' && this.get('username')) {
+      type += '/' + this.get('username');
+    } else if (this.get('name')) {
+      type += '/' + encodeURIComponent(this.get('name'));
+    } else if (typeof(callback) === 'function') {
+      throw 'no_name_specified';
+    }
+  } 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) {
+        console.log('could not get entity');
+      } 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);
+          }
+        }
+      }
+      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');
+    var id = this.getEntityId(this);
+    if (!id) {
+      if (typeof(callback) === 'function') {
+        var error = 'Error trying to delete object - no uuid or name specified.';
+        if (self._client.logging) {
+          console.log(error);
+        }
+        return callback(true, error);
+      }
+    }
+    type += '/' + this.get('uuid');
+    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 {
+        self.set(null);
+      }
+      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;
+
+    //connectee info
+    var connecteeType = entity.get('type');
+    var connectee = this.getEntityId(entity);
+    if (!connectee) {
+      if (typeof(callback) === 'function') {
+        var error = 'Error trying to connect object - no uuid specified.';
+        if (self._client.logging) {
+          console.log(error);
+        }
+        callback(true, error);
+      }
+      return;
+    }
+
+    //connector info
+    var connectorType = this.get('type');
+    var connector = this.getEntityId(this);
+    if (!connector) {
+      if (typeof(callback) === 'function') {
+        var error = 'Error in connect - no uuid specified.';
+        if (self._client.logging) {
+          console.log(error);
+        }
+        callback(true, error);
+      }
+      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) {
+        console.log('entity could not be connected');
+      }
+      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) {
+    return entity.get('uuid') || entity.get('username') || entity.get('name') || false;
+  }
+
+  /*
+  *  gets an entities connections
+  *
+  *  @method getConnections
+  *  @public
+  *  @param {string} connection
+  *  @param {opts} options (actually, just options.qs for now)
+  *  @param {function} callback
+  *  @return {callback} callback(err, data, connections)
+  *
+  */
+  Usergrid.Entity.prototype.getConnections = function (connection, opts, callback) {
+
+    if (typeof(opts) == "function") { callback = opts; opts = undefined; }
+
+    var self = this;
+
+    //connector info
+    var connectorType = inflection.pluralize(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;
+    }
+
+    var endpoint = connectorType + '/' + connector + '/' + connection + '/';
+    var options = {
+      method:'GET',
+      endpoint:endpoint
+    };
+    if (opts && opts.qs) { options.qs = opts.qs; }
+    this._client.request(options, function (err, data) {
+      if (err && self._client.logging) {
+        console.log('entity connections could not be retrieved');
+      }
+
+      self[connection] = {};
+
+      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') {
+        callback(err, data, data.entities);
+      }
+    });
+
+  }
+
+  Usergrid.Entity.prototype.getGroups = function (callback) {
+
+    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) {
+        console.log('entity could not be connected');
+      }
+
+      self['groups'] = data.entities;
+
+      if (typeof(callback) === 'function') {
+        callback(err, data, data.entities);
+      }
+    });
+
+  }
+
+  Usergrid.Entity.prototype.getActivities = function (callback) {
+
+    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) {
+        console.log('entity could not be connected');
+      }
+
+      for(entity in data.entities) {
+        data.entities[entity].createdDate = (new Date(data.entities[entity].created)).toUTCString();
+      }
+
+      self['activities'] = data.entities;
+
+      if (typeof(callback) === 'function') {
+        callback(err, data, data.entities);
+      }
+    });
+
+  }
+
+  Usergrid.Entity.prototype.getFollowing = function (callback) {
+
+    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) {
+        console.log('could not get user following');
+      }
+
+      for(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;
+      }
+
+      self['following'] = data.entities;
+
+      if (typeof(callback) === 'function') {
+        callback(err, data, data.entities);
+      }
+    });
+
+  }
+
+
+  Usergrid.Entity.prototype.getFollowers = function (callback) {
+
+    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) {
+        console.log('could not get user followers');
+      }
+
+      for(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;
+      }
+
+      self['followers'] = data.entities;
+
+      if (typeof(callback) === 'function') {
+        callback(err, data, data.entities);
+      }
+    });
+
+  }
+
+  Usergrid.Entity.prototype.getRoles = function (callback) {
+
+    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) {
+        console.log('could not get user roles');
+      }
+
+      self['roles'] = data.entities;
+
+      if (typeof(callback) === 'function') {
+        callback(err, data, data.entities);
+      }
+    });
+
+  }
+
+  Usergrid.Client.prototype.createRole = function(roleName, permissions, callback) {
+
+      var self = this;
+      var options = {
+          type: 'role',
+          name: roleName
+      };
+
+      this.createEntity(options, function(err, entity, response) {
+          if (err) {
+              callback (err, response, self);
+          } else {
+              entity.assignPermissions(permissions, function (err, data) {
+                  if (err) {
+                      callback (err, response, self);
+                  } else {
+                      callback (err, data, data.data);
+                  }
+              })
+          }
+      });
+
+  };
+  Usergrid.Entity.prototype.assignRole = function(roleName, callback) {
+
+      var self = this;
+      var type = self.get('type');
+      var collection = type + 's';
+      var entityID;
+
+      if (type == 'user' && this.get('username') != null) {
+          entityID = self.get('username');
+      } else if (type == 'group' && this.get('name') != null) {
+          entityID = self.get('name');
+      } else if (this.get('uuid') != null) {
+          entityID = self.get('uuid');
+      }
+
+      if (type != 'users' && type != 'groups') {
+          callback ('entity must be a group or user', null, this);
+      }
+
+      var endpoint = 'roles/' + roleName + '/' + collection + '/' + entityID;
+      var options = {
+          method: 'POST',
+          endpoint: endpoint
+      };
+
+      this._client.request(options, function(err, response) {
+          if (err) {
+              console.log('Could not assign role.');
+          }
+          callback (err, response, self);
+      });
+
+  };
+
+  Usergrid.Entity.prototype.removeRole = function(roleName, callback) {
+
+      var self = this;
+      var type = self.get('type');
+      var collection = type + 's';
+      var entityID;
+
+      if (type == 'user' && this.get('username') != null) {
+          entityID = this.get('username');
+      } else if (type == 'group' && this.get('name') != null) {
+          entityID = this.get('name');
+      } else if (this.get('uuid') != null) {
+          entityID = this.get('uuid');
+      }
+
+      if (type != 'users' && type != 'groups') {
+          callback ('entity must be a group or user', null, this);
+      }
+
+      var endpoint = 'roles/' + roleName + '/' + collection + '/' + entityID;
+      var options = {
+          method: 'DELETE',
+          endpoint: endpoint
+      };
+
+      this._client.request(options, function(err, response) {
+          if (err) {
+              console.log('Could not assign role.');
+          }
+          callback (err, response, self);
+      });
+
+  };
+
+  Usergrid.Entity.prototype.assignPermissions = function(permissions, callback) {
+      var self = this;
+      var entityID;
+      var type = this.get("type");
+
+      if (type != 'user' && type != 'users' && type != 'group' && type != 'groups') {
+          callback( 'entity must be a group or user', null, this);
+      }
+
+      if (type == 'user' && this.get("username") != null) {
+          entityID = this.get("username");
+      } else if (type == 'group' && this.get("name") != null) {
+          entityID = this.get("name");
+      } else if (this.get("uuid") != null) {
+          entityID = this.get("uuid");
+      }
+
+      var endpoint = type + "/" + entityID + "/permissions";
+      var options = {
+          method: "POST",
+          endpoint: endpoint,
+          body: {
+              'permission': permissions
+          }
+      };
+      this._client.request(options, function(err, data) {
+          if (err && self._client.logging) {
+              console.log("could not assign permissions");
+          }
+          callback (err, data, data.data);
+      });
+  };
+
+  Usergrid.Entity.prototype.removePermissions = function(permissions, callback) {
+      var self = this;
+      var entityID;
+      var type = this.get("type");
+
+      if (type != 'user' && type != 'users' && type != 'group' && type != 'groups') {
+          callback ('entity must be a group or user', null, this);
+      }
+
+      if (type == 'user' && this.get("username") != null) {
+          entityID = this.get("username");
+      } else if (type == 'group' && this.get("name") != null) {
+          entityID = this.get("name");
+      } else if (this.get("uuid") != null) {
+          entityID = this.get("uuid");
+      }
+
+      var endpoint = type + "/" + entityID + "/permissions";
+      var options = {
+          method: "DELETE",
+          endpoint: endpoint,
+          qs: {
+              'permission': permissions
+          }
+      };
+      this._client.request(options, function(err, data) {
+          if (err && self._client.logging) {
+              console.log("could not remove permissions");
+          }
+          callback (err, data, data.params.permission);
+      });
+  };
+  Usergrid.Entity.prototype.getPermissions = function (callback) {
+
+    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) {
+        console.log('could not get user permissions');
+      }
+
+      var permissions = [];
+      if (data.data) {
+        var perms = data.data;
+        var count = 0;
+
+        for (var i in perms) {
+          count++;
+          var perm = perms[i];
+          var parts = perm.split(':');
+          var ops_part = "";
+          var path_part = parts[0];
+
+          if (parts.length > 1) {
+            ops_part = parts[0];
+            path_part = parts[1];
+          }
+
+          ops_part.replace("*", "get,post,put,delete")
+          var ops = ops_part.split(',');
+          var ops_object = {}
+          ops_object['get'] = 'no';
+          ops_object['post'] = 'no';
+          ops_object['put'] = 'no';
+          ops_object['delete'] = 'no';
+          for (var j in ops) {
+            ops_object[ops[j]] = 'yes';
+          }
+
+          permissions.push( {operations : ops_object, path : path_part, perm : perm});
+        }
+      }
+
+      self['permissions'] = permissions;
+
+      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;
+
+    //connectee info
+    var connecteeType = entity.get('type');
+    var connectee = this.getEntityId(entity);
+    if (!connectee) {
+      if (typeof(callback) === 'function') {
+        var error = 'Error trying to delete object - no uuid specified.';
+        if (self._client.logging) {
+          console.log(error);
+        }
+        callback(true, error);
+      }
+      return;
+    }
+
+    //connector info
+    var connectorType = this.get('type');
+    var connector = this.getEntityId(this);
+    if (!connector) {
+      if (typeof(callback) === 'function') {
+        var error = 'Error in connect - no uuid specified.';
+        if (self._client.logging) {
+          console.log(error);
+        }
+        callback(true, error);
+      }
+      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) {
+        console.log('entity could not be disconnected');
+      }
+      if (typeof(callback) === 'function') {
+        callback(err, data);
+      }
+    });
+  }
+
+/*
+ *  calls delete on the database w/ the passed query
+ *
+ *  @method delete
+ *  @param {opts} options containing query (include options.qs)
+ *  @param {function} callback
+ *  @return {callback} callback(err, data)
+ *
+ */
+Usergrid.Client.prototype.delete = function(opts, callback) {
+  if (typeof(opts) == "function") { callback = opts; opts = undefined; }
+
+  if (!opts.qs.q) { opts.qs.q = '*'; }
+
+  var options = {
+    method: 'DELETE',
+    endpoint: opts.type,
+    qs: opts.qs
+  };
+  var self = this;
+  this.request(options, function (err, data) {
+    if (err && self.logging) {
+      console.log('entities could not be deleted');
+    }
+    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
+
+      //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++){
+          //make new entity with
+          var entity = this._client.restoreEntity(options.list[i]);
+          this._list[i] = entity;
+        }
+      }
+    }
+    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') {
+
+        collection.resetEntityPointer();
+        while(collection.hasNextEntity()) {
+          var user = collection.getNextEntity();
+          var email = user.get('email');
+          var image = self._client.getDisplayImage(user.get('email'), user.get('picture'));
+          user._portal_image_icon = image;
+        }
+
+        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;
+    } 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 {
+        //save the cursor if there is one
+        var cursor = data.cursor || null;
+        self.saveCursor(cursor);
+        if (data.entities) {
+          self.resetEntityPointer();
+          var count = data.entities.length;
+          //save entities locally
+          self._list = []; //clear the local list first
+          for (var i=0;i<count;i++) {
+            var uuid = data.entities[i].uuid;
+            if (uuid) {
+              var entityData = data.entities[i] || {};
+              self._baseType = data.entities[i].type; //store the base type in the collection
+              entityData.type = self._type;//make sure entities are same type (have same path) as parent collection.
+              var entityOptions = {
+                type:self._type,
+                client:self._client,
+                uuid:uuid,
+                data:entityData
+              };
+
+              var ent = new Usergrid.Entity(entityOptions);
+              ent._json = JSON.stringify(entityData, null, 2);
+              var ct = self._list.length;
+              self._list[ct] = ent;
+            }
+          }
+        }
+      }
+      if (typeof(callback) === 'function') {
+        callback(err, data);
+      }
+    });
+  }
+
+  /*
+  *  Adds a new Entity to the collection (saves, then adds to the local object)
+  *
+  *  @method addNewEntity
+  *  @param {object} entity
+  *  @param {function} callback
+  *  @return {callback} callback(err, data, entity)
+  */
+  Usergrid.Collection.prototype.addEntity = function (options, callback) {
+    var self = this;
+    options.type = this._type;
+
+    //create the new entity
+    this._client.createEntity(options, function (err, entity) {
+      if (!err) {
+        //then add the entity to the list
+        var count = self._list.length;
+        self._list[count] = entity;
+      }
+      if (typeof(callback) === 'function') {
+        callback(err, entity);
+      }
+    });
+  }
+
+  Usergrid.Collection.prototype.addExistingEntity = function (entity) {
+    //entity should already exist in the db, so just add it to the list
+    var count = this._list.length;
+    this._list[count] = entity;
+  }
+
+  /*
+  *  Removes the Entity from the collection, then destroys the object on the server
+  *
+  *  @method destroyEntity
+  *  @param {object} entity
+  *  @param {function} callback
+  *  @return {callback} callback(err, data)
+  */
+  Usergrid.Collection.prototype.destroyEntity = function (entity, callback) {
+    var self = this;
+    entity.destroy(function(err, data) {
+      if (err) {
+        if (self._client.logging) {
+          console.log('could not destroy entity');
+        }
+        if (typeof(callback) === 'function') {
+          callback(err, data);
+        }
+      } else {
+        //destroy was good, so repopulate the collection
+        self.fetch(callback);
+      }
+    });
+    //remove entity from the local store
+    this.removeEntity(entity);
+  }
+
+
+  Usergrid.Collection.prototype.removeEntity = function (entity) {
+    var uuid = entity.get('uuid');
+    for (key in this._list) {
+      var listItem = this._list[key];
+      if (listItem.get('uuid') === uuid) {
+        return this._list.splice(key, 1);
+      }
+    }
+    return false;
+  }
+
+  /*
+  *  Looks up an Entity by UUID
+  *
+  *  @method getEntityByUUID
+  *  @param {string} UUID
+  *  @param {function} callback
+  *  @return {callback} callback(err, data, entity)
+  */
+  Usergrid.Collection.prototype.getEntityByUUID = function (uuid, callback) {
+
+    for (key in this._list) {
+      var listItem = this._list[key];
+      if (listItem.get('uuid') === uuid) {
+        return listItem;
+      }
+    }
+
+    //get the entity from the database
+    var options = {
+      data: {
+        type: this._type,
+        uuid:uuid
+      },
+      client: this._client
+    }
+    var entity = new Usergrid.Entity(options);
+    entity.fetch(callback);
+  }
+
+  /*
+  *  Returns the first Entity of the Entity list - does not affect the iterator
+  *
+  *  @method getFirstEntity
+  *  @return {object} returns an entity object
+  */
+  Usergrid.Collection.prototype.getFirstEntity = function () {
+    var count = this._list.length;
+    if (count > 0) {
+      return this._list[0];
+    }
+    return null;
+  }
+
+  /*
+  *  Returns the last Entity of the Entity list - does not affect the iterator
+  *
+  *  @method getLastEntity
+  *  @return {object} returns an entity object
+  */
+  Usergrid.Collection.prototype.getLastEntity = function () {
+    var count = this._list.length;
+    if (count > 0) {
+      return this._list[count-1];
+    }
+    return null;
+  }
+
+  /*
+  *  Entity iteration -Checks to see if there is a "next" entity
+  *  in the list.  The first time this method is called on an entity
+  *  list, or after the resetEntityPointer method is called, it will
+  *  return true referencing the first entity in the list
+  *
+  *  @method hasNextEntity
+  *  @return {boolean} true if there is a next entity, false if not
+  */
+  Usergrid.Collection.prototype.hasNextEntity = function () {
+    var next = this._iterator + 1;
+    var hasNextElement = (next >=0 && next < this._list.length);
+    if(hasNextElement) {
+      return true;
+    }
+    return false;
+  }
+
+  /*
+  *  Entity iteration - Gets the "next" entity in the list.  The first
+  *  time this method is called on an entity list, or after the method
+  *  resetEntityPointer is called, it will return the,
+  *  first entity in the list
+  *
+  *  @method hasNextEntity
+  *  @return {object} entity
+  */
+  Usergrid.Collection.prototype.getNextEntity = function () {
+    this._iterator++;
+    var hasNextElement = (this._iterator >= 0 && this._iterator <= this._list.length);
+    if(hasNextElement) {
+      return this._list[this._iterator];
+    }
+    return false;
+  }
+
+  /*
+  *  Entity iteration - Checks to see if there is a "previous"
+  *  entity in the list.
+  *
+  *  @method hasPrevEntity
+  *  @return {boolean} true if there is a previous entity, false if not
+  */
+  Usergrid.Collection.prototype.hasPrevEntity = function () {
+    var previous = this._iterator - 1;
+    var hasPreviousElement = (previous >=0 && previous < this._list.length);
+    if(hasPreviousElement) {
+      return true;
+    }
+    return false;
+  }
+
+  /*
+  *  Entity iteration - Gets the "previous" entity in the list.
+  *
+  *  @method getPrevEntity
+  *  @return {object} entity
+  */
+  Usergrid.Collection.prototype.getPrevEntity = function () {
+     this._iterator--;
+     var hasPreviousElement = (this._iterator >= 0 && this._iterator <= this._list.length);
+     if(hasPreviousElement) {
+      return this.list[this._iterator];
+     }
+     return false;
+  }
+
+  /*
+  *  Entity iteration - Resets the iterator back to the beginning
+  *  of the list
+  *
+  *  @method resetEntityPointer
+  *  @return none
+  */
+  Usergrid.Collection.prototype.resetEntityPointer = function () {
+     this._iterator  = -1;
+  }
+
+  /*
+  * Method to save off the cursor just returned by the last API call
+  *
+  * @public
+  * @method saveCursor
+  * @return none
+  */
+  Usergrid.Collection.prototype.saveCursor = function(cursor) {
+    //if current cursor is different, grab it for next cursor
+    if (this._next !== cursor) {
+      this._next = cursor;
+    }
+  }
+
+  /*
+  * Resets the paging pointer (back to original page)
+  *
+  * @public
+  * @method resetPaging
+  * @return none
+  */
+  Usergrid.Collection.prototype.resetPaging = function() {
+    this._previous = [];
+    this._next = null;
+    this._cursor = null;
+  }
+
+  /*
+  *  Paging -  checks to see if there is a next page od data
+  *
+  *  @method hasNextPage
+  *  @return {boolean} returns true if there is a next page of data, false otherwise
+  */
+  Usergrid.Collection.prototype.hasNextPage = function () {
+    return !!this._next;
+  }
+
+  /*
+  *  Paging - advances the cursor and gets the next
+  *  page of data from the API.  Stores returned entities
+  *  in the Entity list.
+  *
+  *  @method getNextPage
+  *  @param {function} callback
+  *  @return {callback} callback(err, data)
+  */
+  Usergrid.Collection.prototype.getNextPage = function (callback) {
+    if (this.hasNextPage()) {
+      //set the cursor to the next page of data
+      this._previous.push(this._cursor);
+      this._cursor = this._next;
+      //empty the list
+      this._list = [];
+      this.fetch(callback);
+    }
+  }
+
+  /*
+  *  Paging -  checks to see if there is a previous page od data
+  *
+  *  @method hasPreviousPage
+  *  @return {boolean} returns true if there is a previous page of data, false otherwise
+  */
+  Usergrid.Collection.prototype.hasPreviousPage = function () {
+    return (this._previous.length > 0);
+  }
+
+  /*
+  *  Paging - reverts the cursor and gets the previous
+  *  page of data from the API.  Stores returned entities
+  *  in the Entity list.
+  *
+  *  @method getPreviousPage
+  *  @param {function} callback
+  *  @return {callback} callback(err, data)
+  */
+  Usergrid.Collection.prototype.getPreviousPage = function (callback) {
+    if (this.hasPreviousPage()) {
+      this._next=null; //clear out next so the comparison will find the next item
+      this._cursor = this._previous.pop();
+      //empty the list
+      this._list = [];
+      this.fetch(callback);
+    }
+  }
+
+
+  /*
+   *  A class to model a Usergrid group.
+   *  Set the path in the options object.
+   *
+   *  @constructor
+   *  @param {object} options {client:client, data: {'key': 'value'}, path:'path'}
+   */
+  Usergrid.Group = function(options, callback) {
+    this._path = options.path;
+    this._list = [];
+    this._client = options.client;
+    this._data = options.data || {};
+    this._data.type = "groups";
+  }
+
+  /*
+   *  Inherit from Usergrid.Entity.
+   *  Note: This only accounts for data on the group object itself.
+   *  You need to use add and remove to manipulate group membership.
+   */
+  Usergrid.Group.prototype = new Usergrid.Entity();
+
+  /*
+  *  Fetches current group data, and members.
+  *
+  *  @method fetch
+  *  @public
+  *  @param {function} callback
+  *  @returns {function} callback(err, data)
+  */
+  Usergrid.Group.prototype.fetch = function(callback) {
+    var self = this;
+    var groupEndpoint = 'groups/'+this._path;
+    var memberEndpoint = 'groups/'+this._path+'/users';
+
+    var groupOptions = {
+      method:'GET',
+      endpoint:groupEndpoint
+    }
+
+    var memberOptions = {
+      method:'GET',
+      endpoint:memberEndpoint
+    }
+
+    this._client.request(groupOptions, function(err, data){
+      if(err) {
+        if(self._client.logging) {
+          console.log('error getting group');
+        }
+        if(typeof(callback) === 'function') {
+          callback(err, data);
+        }
+      } else {
+        if(data.entities) {
+          var groupData = data.entities[0];
+          self._data = groupData || {};
+          self._client.request(memberOptions, function(err, data) {
+            if(err && self._client.logging) {
+              console.log('error getting group users');
+            } else {
+              if(data.entities) {
+                var count = data.entities.length;
+                self._list = [];
+                for (var i = 0; i < count; i++) {
+                  var uuid = data.entities[i].uuid;
+                  if(uuid) {
+                    var entityData = data.entities[i] || {};
+                    var entityOptions = {
+                      type: entityData.type,
+                      client: self._client,
+                      uuid:uuid,
+                      data:entityData
+                    };
+                    var entity = new Usergrid.Entity(entityOptions);
+                    self._list.push(entity);
+                  }
+
+                }
+              }
+            }
+            if(typeof(callback) === 'function') {
+              callback(err, data, self._list);
+            }
+          });
+        }
+      }
+    });
+  }
+
+  /*
+   *  Retrieves the members of a group.
+   *
+   *  @method members
+   *  @public
+   *  @param {function} callback
+   *  @return {function} callback(err, data);
+   */
+  Usergrid.Group.prototype.members = function(callback) {
+    if(typeof(callback) === 'function') {
+      callback(null, this._list);
+    }
+  }
+
+  /*
+   *  Adds a user to the group, and refreshes the group object.
+   *
+   *  Options object: {user: user_entity}
+   *
+   *  @method add
+   *  @public
+   *  @params {object} options
+   *  @param {function} callback
+   *  @return {function} callback(err, data)
+   */
+  Usergrid.Group.prototype.add = function(options, callback) {
+    var self = this;
+    var options = {
+      method:"POST",
+      endpoint:"groups/"+this._path+"/users/"+options.user.get('username')
+    }
+
+    this._client.request(options, function(error, data){
+      if(error) {
+        if(typeof(callback) === 'function') {
+          callback(error, data, data.entities);
+        }
+      } else {
+        self.fetch(callback);
+      }
+    });
+  }
+
+  /*
+   *  Removes a user from a group, and refreshes the group object.
+   *
+   *  Options object: {user: user_entity}
+   *
+   *  @method remove
+   *  @public
+   *  @params {object} options
+   *  @param {function} callback
+   *  @return {function} callback(err, data)
+   */
+  Usergrid.Group.prototype.remove = function(options, callback) {
+    var self = this;
+
+    var options = {
+      method:"DELETE",
+      endpoint:"groups/"+this._path+"/users/"+options.user.username
+    }
+
+    this._client.request(options, function(error, data){
+      if(error) {
+        if(typeof(callback) === 'function') {
+          callback(error, data);
+        }
+      } else {
+        self.fetch(callback);
+      }
+    });
+  }
+
+  /*
+  * Gets feed for a group.
+  *
+  * @public
+  * @method feed
+  * @param {function} callback
+  * @returns {callback} callback(err, data, activities)
+  */
+  Usergrid.Group.prototype.feed = function(callback) {
+    var self = this;
+
+    var endpoint = "groups/"+this._path+"/feed";
+
+    var options = {
+      method:"GET",
+      endpoint:endpoint
+    }
+
+    this._client.request(options, function(err, data){
+      if (err && self.logging) {
+        console.log('error trying to log user in');
+      }
+      if(typeof(callback) === 'function') {
+          callback(err, data, data.entities);
+      }
+    });
+  }
+
+  /*
+  * Creates activity and posts to group feed.
+  *
+  * options object: {user: user_entity, content: "activity content"}
+  *
+  * @public
+  * @method createGroupActivity
+  * @params {object} options
+  * @param {function} callback
+  * @returns {callback} callback(err, entity)
+  */
+  Usergrid.Group.prototype.createGroupActivity = function(options, callback){
+    var user = options.user;
+    var options = {
+      actor: {
+        "displayName":user.get("username"),
+        "uuid":user.get("uuid"),
+        "username":user.get("username"),
+        "email":user.get("email"),
+        "picture":user.get("picture"),
+        "image": {
+          "duration":0,
+          "height":80,
+          "url":user.get("picture"),
+          "width":80
+         },
+      },
+      "verb":"post",
+      "content":options.content };
+
+      options.type = 'groups/'+this._path+'/activities';
+      var options = {
+        client:this._client,
+        data:options
+      }
+
+      var entity = new Usergrid.Entity(options);
+      entity.save(function(err, data) {
+        if (typeof(callback) === 'function') {
+          callback(err, entity);
+        }
+      });
+  }
+
+  /*
+  * Tests if the string is a uuid
+  *
+  * @public
+  * @method isUUID
+  * @param {string} uuid The string to test
+  * @returns {Boolean} true if string is uuid
+  */
+  function isUUID (uuid) {
+    var uuidValueRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+    if (!uuid) return false;
+    return uuidValueRegex.test(uuid);
+  }
+
+  /*
+  *  method to encode the query string parameters
+  *
+  *  @method encodeParams
+  *  @public
+  *  @params {object} params - an object of name value pairs that will be urlencoded
+  *  @return {string} Returns the encoded string
+  */
+  function encodeParams (params) {
+    tail = [];
+    var item = [];
+    if (params instanceof Array) {
+      for (i in params) {
+        item = params[i];
+        if ((item instanceof Array) && (item.length > 1)) {
+          tail.push(item[0] + "=" + encodeURIComponent(item[1]));
+        }
+      }
+    } else {
+      for (var key in params) {
+        if (params.hasOwnProperty(key)) {
+          var value = params[key];
+          if (value instanceof Array) {
+            for (i in value) {
+              item = value[i];
+              tail.push(key + "=" + encodeURIComponent(item));
+            }
+          } else {
+            tail.push(key + "=" + encodeURIComponent(value));
+          }
+        }
+      }
+    }
+    return tail.join("&");
+  }
+/*
+ *  A class to model a Usergrid event.
+ *
+ *  @constructor
+ *  @param {object} options {timestamp:0, category:'value', counters:{name : value}}
+ *  @returns {callback} callback(err, event)
+ */
+Usergrid.Counter = function(options, callback) {
+  var self=this;
+  this._client = options.client;
+  this._data = options.data || {};
+  this._data.category = options.category||"UNKNOWN";
+  this._data.timestamp = options.timestamp||0;
+  this._data.type = "events";
+  this._data.counters=options.counters||{};
+  if(typeof(callback) === 'function') {
+    callback.call(self, false, self);
+  }
+  //this.save(callback);
+};
+var COUNTER_RESOLUTIONS=[
+  'all', 'minute', 'five_minutes', 'half_hour',
+  'hour', 'six_day', 'day', 'week', 'month'
+];
+/*
+ *  Inherit from Usergrid.Entity.
+ *  Note: This only accounts for data on the group object itself.
+ *  You need to use add and remove to manipulate group membership.
+ */
+Usergrid.Counter.prototype = new Usergrid.Entity();
+
+/*
+ * overrides Entity.prototype.fetch. Returns all data for counters
+ * associated with the object as specified in the constructor
+ *
+ * @public
+ * @method increment
+ * @param {function} callback
+ * @returns {callback} callback(err, event)
+ */
+Usergrid.Counter.prototype.fetch=function(callback){
+  this.getData({}, callback);
+}
+/*
+ * increments the counter for a specific event
+ *
+ * options object: {name: counter_name}
+ *
+ * @public
+ * @method increment
+ * @params {object} options
+ * @param {function} callback
+ * @returns {callback} callback(err, event)
+ */
+Usergrid.Counter.prototype.increment=function(options, callback){
+  var self=this,
+    name=options.name,
+    value=options.value;
+  if(!name){
+    if(typeof(callback) === 'function') {
+      return callback.call(self, true, "'value' for increment, decrement must be a number");
+    }
+  }else if(isNaN(value)){
+    if(typeof(callback) === 'function') {
+      return callback.call(self, true, "'value' for increment, decrement must be a number");
+    }
+  }else{
+    self._data.counters[name]=(parseInt(value))||1;
+    return self.save(callback);
+  }
+};
+/*
+ * decrements the counter for a specific event
+ *
+ * options object: {name: counter_name}
+ *
+ * @public
+ * @method decrement
+ * @params {object} options
+ * @param {function} callback
+ * @returns {callback} callback(err, event)
+ */
+
+Usergrid.Counter.prototype.decrement=function(options, callback){
+  var self=this,
+    name=options.name,
+    value=options.value;
+  self.increment({name:name, value:-((parseInt(value))||1)}, callback);
+};
+/*
+ * resets the counter for a specific event
+ *
+ * options object: {name: counter_name}
+ *
+ * @public
+ * @method reset
+ * @params {object} options
+ * @param {function} callback
+ * @returns {callback} callback(err, event)
+ */
+
+Usergrid.Counter.prototype.reset=function(options, callback){
+  var self=this,
+    name=options.name;
+  self.increment({name:name, value:0}, callback);
+};
+
+/*
+ * gets data for one or more counters over a given
+ * time period at a specified resolution
+ *
+ * options object: {
+ *                   counters: ['counter1', 'counter2', ...],
+ *                   start: epoch timestamp or ISO date string,
+ *                   end: epoch timestamp or ISO date string,
+ *                   resolution: one of ('all', 'minute', 'five_minutes', 'half_hour', 'hour', 'six_day', 'day', 'week', or 'month')
+ *                   }
+ *
+ * @public
+ * @method getData
+ * @params {object} options
+ * @param {function} callback
+ * @returns {callback} callback(err, event)
+ */
+Usergrid.Counter.prototype.getData=function(options, callback){
+  var start_time,
+      end_time,
+      start=options.start||0,
+      end=options.end||Date.now(),
+      resolution=(options.resolution||'all').toLowerCase(),
+      counters=options.counters||Object.keys(this._data.counters),
+      res=(resolution||'all').toLowerCase();
+  if(COUNTER_RESOLUTIONS.indexOf(res)===-1){
+    res='all';
+  }
+  if(start){
+    switch(typeof start){
+      case "undefined":
+        start_time=0;
+        break;
+      case "number":
+        start_time=start;
+        break;
+      case "string":
+        start_time=(isNaN(start))?Date.parse(start):parseInt(start);
+        break;
+      default:
+        start_time=Date.parse(start.toString());
+    }
+  }
+  if(end){
+    switch(typeof end){
+      case "undefined":
+        end_time=Date.now();
+        break;
+      case "number":
+        end_time=end;
+        break;
+      case "string":
+        end_time=(isNaN(end))?Date.parse(end):parseInt(end);
+        break;
+      default:
+        end_time=Date.parse(end.toString());
+    }
+  }
+  var self=this;
+  //https://api.usergrid.com/yourorgname/sandbox/counters?counter=test_counter
+  var params=Object.keys(counters).map(function(counter){
+      return ["counter", encodeURIComponent(counters[counter])].join('=');
+    });
+  params.push('resolution='+res)
+  params.push('start_time='+String(start_time))
+  params.push('end_time='+String(end_time))
+
+  var endpoint="counters?"+params.join('&');
+  this._client.request({endpoint:endpoint}, function(err, data){
+    if(data.counters && data.counters.length){
+      data.counters.forEach(function(counter){
+        self._data.counters[counter.name]=counter.value||counter.values;
+      })
+    }
+    if(typeof(callback) === 'function') {
+      callback.call(self, err, data);
+    }
+  })
+};
+
+exports.client = Usergrid.Client;
+exports.entity = Usergrid.Entity;
+exports.collection = Usergrid.Collection;
+exports.group = Usergrid.Group;
+exports.counter = Usergrid.Counter;
+exports.AUTH_CLIENT_ID = AUTH_CLIENT_ID;
+exports.AUTH_APP_USER = AUTH_APP_USER;
+exports.AUTH_NONE = AUTH_NONE;

http://git-wip-us.apache.org/repos/asf/usergrid-nodejs/blob/7b92555b/package.json
----------------------------------------------------------------------
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..2d2579d
--- /dev/null
+++ b/package.json
@@ -0,0 +1,43 @@
+{
+  "name": "usergrid",
+  "version": "0.10.8",
+  "description": "A Node.js module for making API calls to App Services (Usergrid) from within Node.js",
+  "main": "./lib/usergrid.js",
+  "dependencies": {
+    "request": "2.12.x",
+    "inflection": "1.3.x"
+  },
+  "devDependencies": {
+    "mocha": "1.7.x",
+    "should": "1.2.1"
+  },
+  "scripts": {
+    "test": "mocha",
+    "start": "node example/server.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/apigee/usergrid-node-module.git"
+  },
+  "bugs": {
+    "url": "http://github.com/apigee/usergrid-node-module.git/issues"
+  },
+  "keywords": [
+    "Node",
+    "Usergrid",
+    "Apigee",
+    "API"
+  ],
+  "tags": [
+    "usergrid",
+    "API",
+    "Apigee"
+  ],
+  "author": {
+    "name": "Rod Simpson",
+    "email": "rod@rodsimpson.com",
+    "url" : "http://rodsimpson.com"
+  },
+  "license": "Apache 2.0"
+}
+


Mime
View raw message