Users client generated by apidoc

apidoc.users.js

var request = require('request');

/**
 * ## Responses
 * Responses from this API with be wrapped in an envelope to assist the caller
 * in dealing with the various responses from the service. There are no types
 * to check against in JavaScript, so this facilitates that.
 *
 *    {
 *      status: 200,
 *      data: { name: "John", age: 29 }
 *    }
 *
 * ## Logging
 * To enable logging, use the NODE_DEBUG environment variable.
 *
 *    NODE_DEBUG=apidoc
 *
 * @constructor
 */
function Users (host) {
  var showLogMessages = process.env.NODE_DEBUG ? process.env.NODE_DEBUG.indexOf('apidoc') !== -1 : false;

  function log (message) {
    if (showLogMessages) {
      console.log('[apidoc] ' + message);
    }
  }

  function doRequest (options) {
    var startMs = Date.now();
    options = options || {};

    if (!options.json) {
      options.json = true;
    }

    log(options.method + ' ' + options.uri);
    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH') {
      log('|--> With body:\n\t\t' + JSON.stringify(options.json));
    }

    return new Promise(function (resolve, reject) {
      request(options, function (err, response) {
        var duration = Date.now() - startMs;

        log('Completed ' + options.method + ' ' + options.uri + ' ' + response.statusCode + ' ' + duration + 'ms');

        if (err) {
          reject(err);
          return;
        }

        resolve(response);
      });
    });
  }

  function toCamelCase (string) {
    var parts = string.split('_');
    var capitalized = parts.map(function (part, idx) {
      if (idx > 0) {
        return capitalizeFirstLetter(part);
      }

      return part;
    });

    return capitalized.join('');
  }

  function capitalizeFirstLetter (string) {
      return string.charAt(0).toUpperCase() + string.slice(1);
  }

  /**
   * Simple plain object check. This is actually really involved to be 100%
   * accurate
   */
  function isObject (obj) {
    return typeof obj === 'object' && !Array.isArray(obj);
  }

  var AccountDetail = (function AccountDetail() {
      /**
       * Get account details for a user.
       * 
       * @param {string} guid
       */
      function getByGuid(guid) {


        var url = host + '/account_details/' + guid + '';
        var requestOpts = {
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 404:
              return Promise.resolve( { status: serverResponse.statusCode } );
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

      /**
       * Update account details for a user. Must provide all data. Anything left out will be lost
       * 
       * @param {string} guid
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function putByGuid(guid, options) {
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/account_details/' + guid + '';
        var requestOpts = {
          json: options.data,
          uri: url,
          method: 'PUT'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 404:
              return Promise.resolve( { status: serverResponse.statusCode } );
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }


    return {
      getByGuid: getByGuid,
      putByGuid: putByGuid,
    };
  }());

  var ForgotPassword = (function ForgotPassword() {
      /**
       * Creates forgot password request for a user identified by the provided email address.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/forgot_passwords';
        var requestOpts = {
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

      /**
       * Validates a forgot password token. If valid, return true.
       * 
       * @param {string} token
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function putByToken(token, options) {


        var url = host + '/forgot_passwords/' + token + '';
        var requestOpts = {
          json: options.data,
          uri: url,
          method: 'PUT'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }


    return {
      post: post,
      putByToken: putByToken,
    };
  }());

  var Healthcheck = (function Healthcheck() {
      /**
       * Healthcheck for this service
       * 
       */
      function get() {


        var url = host + '/healthchecks';
        var requestOpts = {
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }


    return {
      get: get,
    };
  }());

  var HireRequest = (function HireRequest() {
      /**
       * Create a hire request. Emails Customer Service with details.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/hire_requests';
        var requestOpts = {
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }


    return {
      post: post,
    };
  }());

  var User = (function User() {
      /**
       * Find a user.
       * 
       * @param {Object} options
       * @param {string} options.guid
       * @param {string} options.email
       * @param {string} options.vanityKey
       */
      function get(options) {


        var url = host + '/users';
        var requestOpts = {
          guid: options[toCamelCase('guid')],
          email: options[toCamelCase('email')],
          vanity_key: options[toCamelCase('vanity_key')],
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

      /**
       * Creates a user.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function post(options) {
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/users';
        var requestOpts = {
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

      /**
       * Authenticate a user.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postAuthenticate(options) {
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/users/authenticate';
        var requestOpts = {
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

      /**
       * Follow a user.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postFollow(options) {
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/users/follow';
        var requestOpts = {
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

      /**
       * Unfollow a user.
       * 
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function postUnfollow(options) {
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/users/unfollow';
        var requestOpts = {
          json: options.data,
          uri: url,
          method: 'POST'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

      /**
       * Gets the people following the user
       * 
       * @param {string} guid
       */
      function getFollowersByGuid(guid) {


        var url = host + '/users/followers/' + guid + '';
        var requestOpts = {
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

      /**
       * Gets the people the user follows
       * 
       * @param {string} guid
       */
      function getFollowingByGuid(guid) {


        var url = host + '/users/following/' + guid + '';
        var requestOpts = {
          uri: url,
          method: 'GET'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }

      /**
       * Update information about a user.
       * 
       * @param {string} guid
       * @param {Object} options
       * @param {Object} options.data - The request body
       */
      function putByGuid(guid, options) {
        if (!isObject(options)) {
          return Promise.reject(new Error('options parameter is required and must be a plain object'));
        }

        if (!options.data) {
          return Promise.reject(new Error('options.data property is required.'));
        }

        var url = host + '/users/' + guid + '';
        var requestOpts = {
          json: options.data,
          uri: url,
          method: 'PUT'
        };

        return doRequest(requestOpts).then(function (serverResponse) {
          switch (serverResponse.statusCode) {
            case 200:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            case 409:
              return Promise.resolve({ status: serverResponse.statusCode, data: serverResponse.body });
            default:
              return Promise.reject(new Error('Unknown response code: ' + serverResponse.statusCode));
          }
        });
      }


    return {
      get: get,
      post: post,
      postAuthenticate: postAuthenticate,
      postFollow: postFollow,
      postUnfollow: postUnfollow,
      getFollowersByGuid: getFollowersByGuid,
      getFollowingByGuid: getFollowingByGuid,
      putByGuid: putByGuid,
    };
  }());

  this.AccountDetail = AccountDetail;
  this.ForgotPassword = ForgotPassword;
  this.Healthcheck = Healthcheck;
  this.HireRequest = HireRequest;
  this.User = User;
}



module.exports = Users;