Initial Commit of v0.1.0

Author: ningsuhen

.npmignore

@@ -0,0 +1,8 @@
+*.md
+.DS_Store
+.git*
+Makefile
+docs/
+examples/
+support/
+test/

.travis.yml

@@ -0,0 +1,5 @@
+language: "node_js"
+node_js:
+  - 0.4
+  - 0.6
+  - 0.8

LICENSE

@@ -0,0 +1,20 @@
+(The MIT License)
+
+Copyright (c) 2012 Ningsuhen Waikhom
+
+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.

README.md

@@ -0,0 +1,88 @@
+# Passport-LinkedIn-Token
+
+[Passport](http://passportjs.org/) strategy for authenticating with [LinkedIn](http://linkedin.com/) tokens
+using the OAuth 1.0a API.
+
+This module lets you authenticate using LinkedIn in your Node.js applications.
+By plugging into Passport, LinkedIn authentication can be easily and
+unobtrusively integrated into any application or framework that supports
+[Connect](http://www.senchalabs.org/connect/)-style middleware, including
+[Express](http://expressjs.com/).
+
+## Installation
+
+    $ npm install passport-linkedin-token
+
+## Usage
+
+#### Configure Strategy
+
+The LinkedIn authentication strategy authenticates users using a LinkedIn account
+and OAuth tokens.  The strategy requires a `verify` callback, which receives the
+access token and corresponding secret as arguments, as well as `profile` which
+contains the authenticated user's LinkedIn profile.   The `verify` callback must
+call `done` providing a user to complete authentication.
+
+In order to identify your application to LinkedIn, specify the consumer key,
+consumer secret, and callback URL within `options`.  The consumer key and secret
+are obtained by [creating an application](https://dev.linkedin.com/apps) at
+LinkedIn's [developer](https://dev.linkedin.com/) site.
+
+```javascript
+passport.use(new LinkedInTokenStrategy({
+    consumerKey: LINKEDIN_CONSUMER_KEY,
+    consumerSecret: LINKEDIN_CONSUMER_SECRET
+  },
+  function(token, tokenSecret, profile, done) {
+    User.findOrCreate({ linkedinId: profile.id }, function (err, user) {
+      return done(err, user);
+    });
+  }
+));
+```
+#### Authenticate Requests
+
+Use `passport.authenticate()`, specifying the `'linkedin-token'` strategy, to
+authenticate requests.
+
+For example, as route middleware in an [Express](http://expressjs.com/)
+application:
+
+```javascript
+app.post('/auth/linkedin/token',
+  passport.authenticate('linkedin-token'),
+  function (req, res) {
+    // do something with req.user
+    res.send(req.user? 200 : 401);
+  }
+);
+```
+
+## Credits
+
+  - [Ningsuhen Waikhom](http://github.com/ningsuhen)
+  - [Nicholas Penree](https://github.com/drudge/passport-twitter-token)
+  - [Jared Hanson](http://github.com/jaredhanson)
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2012 Nicholas Penree
+
+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.

lib/passport-linkedin-token/index.js

@@ -0,0 +1,15 @@
+/**
+ * Module dependencies.
+ */
+var Strategy = require('./strategy');
+
+
+/**
+ * Framework version.
+ */
+require('pkginfo')(module, 'version');
+
+/**
+ * Expose constructors.
+ */
+exports.Strategy = Strategy;

lib/passport-linkedin-token/strategy.js

@@ -0,0 +1,184 @@
+/**
+ * Module dependencies.
+ */
+var util = require('util')
+  , OAuthStrategy = require('passport-oauth').OAuthStrategy
+  , InternalOAuthError = require('passport-oauth').InternalOAuthError;
+
+
+/**
+ * `LinkedInTokenStrategy` constructor.
+ *
+ * The LinkedIn authentication strategy authenticates requests by delegating to
+ * LinkedIn using the OAuth protocol.
+ *
+ * Applications must supply a `verify` callback which accepts a `token`,
+ * `tokenSecret` and service-specific `profile`, and then calls the `done`
+ * callback supplying a `user`, which should be set to `false` if the
+ * credentials are not valid.  If an exception occured, `err` should be set.
+ *
+ * Options:
+ *   - `consumerKey`     identifies client to LinkedIn
+ *   - `consumerSecret`  secret used to establish ownership of the consumer key
+ *
+ * Examples:
+ *
+ *     passport.use(new LinkedInTokenStrategy({
+ *         consumerKey: '123-456-789',
+ *         consumerSecret: 'shhh-its-a-secret'
+ *       },
+ *       function(token, tokenSecret, profile, done) {
+ *         User.findOrCreate(..., function (err, user) {
+ *           done(err, user);
+ *         });
+ *       }
+ *     ));
+ *
+ * @param {Object} options
+ * @param {Function} verify
+ * @api public
+ */
+function LinkedInTokenStrategy(options, verify) {
+  options = options || {};
+  options.requestTokenURL = options.requestTokenURL || 'https://api.linkedin.com/uas/oauth/requestToken';
+  options.accessTokenURL = options.accessTokenURL || 'https://api.linkedin.com/uas/oauth/accessToken';
+  options.userAuthorizationURL = options.userAuthorizationURL || 'https://www.linkedin.com/uas/oauth/authenticate';
+  options.sessionKey = options.sessionKey || 'oauth:linkedin';
+
+  OAuthStrategy.call(this, options, verify);
+  this.name = 'linkedin-token';
+
+  this._skipExtendedUserProfile = (options.skipExtendedUserProfile === undefined) ? false : options.skipExtendedUserProfile;
+}
+
+/**
+ * Inherit from `OAuthLinkedInTokenStrategy`.
+ */
+util.inherits(LinkedInTokenStrategy, OAuthStrategy);
+
+
+/**
+ * Authenticate request by delegating to LinkedIn using OAuth.
+ *
+ * @param {Object} req
+ * @api protected
+ */
+LinkedInTokenStrategy.prototype.authenticate = function(req, options) {
+  // When a user denies authorization on LinkedIn, they are presented with a link
+  // to return to the application in the following format (where xxx is the
+  // value of the request token):
+  //
+  //     http://www.example.com/auth/linkedin/callback?denied=xxx
+  //
+  // Following the link back to the application is interpreted as an
+  // authentication failure.
+  if (req.query && req.query.denied) {
+    return this.fail();
+  }
+  
+  var self = this;
+  var token = req.body.oauth_token || req.query.oauth_token;
+  var tokenSecret = req.body.oauth_token_secret || req.query.oauth_token_secret;
+  
+  var params = { };
+  
+  self._loadUserProfile(token, tokenSecret, params, function(err, profile) {
+    if (err) { return self.error(err); };
+    
+    function verified(err, user, info) {
+      if (err) { return self.error(err); }
+      if (!user) { return self.fail(info); }
+      self.success(user, info);
+    }
+    
+    if (self._passReqToCallback) {
+      var arity = self._verify.length;
+      if (arity == 6) {
+        self._verify(req, token, tokenSecret, params, profile, verified);
+      } else { // arity == 5
+        self._verify(req, token, tokenSecret, profile, verified);
+      }
+    } else {
+      var arity = self._verify.length;
+      if (arity == 5) {
+        self._verify(token, tokenSecret, params, profile, verified);
+      } else { // arity == 4
+        self._verify(token, tokenSecret, profile, verified);
+      }
+    }
+  });
+}
+
+/**
+ * Retrieve user profile from LinkedIn.
+ *
+ * This function constructs a normalized profile, with the following properties:
+ *
+ *   - `id`        (equivalent to `user_id`)
+ *   - `username`  (equivalent to `screen_name`)
+ *
+ * Note that because LinkedIn supplies basic profile information in query
+ * parameters when redirecting back to the application, loading of LinkedIn
+ * profiles *does not* result in an additional HTTP request, when the
+ * `skipExtendedUserProfile` is enabled.
+ *
+ * @param {String} token
+ * @param {String} tokenSecret
+ * @param {Object} params
+ * @param {Function} done
+ * @api protected
+ */
+LinkedInTokenStrategy.prototype.userProfile = function(token, tokenSecret, params, done) {
+  var url = 'https://api.linkedin.com/v1/people/~:(id,first-name,last-name,public-profile-url)?format=json';
+  if (this._profileFields) {
+    var fields = this._convertProfileFields(this._profileFields);
+    url = 'https://api.linkedin.com/v1/people/~:(' + fields + ')?format=json';
+  }
+
+  this._oauth.get(url, token, tokenSecret, function (err, body, res) {
+    if (err) { return done(new InternalOAuthError('failed to fetch user profile', err)); }
+    
+    try {
+      var json = JSON.parse(body);
+      
+      var profile = { provider: 'linkedin' };
+      profile.id = json.id;
+      profile.displayName = json.firstName + ' ' + json.lastName;
+      profile.name = { familyName: json.lastName,
+                       givenName: json.firstName };
+      if (json.emailAddress) { profile.emails = [{ value: json.emailAddress }]; }
+      
+      profile._raw = body;
+      profile._json = json;
+      
+      done(null, profile);
+    } catch(e) {
+      done(e);
+    }
+  });
+}
+
+/**
+ * Return extra LinkedIn-specific parameters to be included in the user
+ * authorization request.
+ *
+ * @param {Object} options
+ * @return {Object}
+ * @api protected
+ */
+LinkedInTokenStrategy.prototype.userAuthorizationParams = function(options) {
+  var params = {};
+  if (options.forceLogin) {
+    params['force_login'] = options.forceLogin;
+  }
+  if (options.screenName) {
+    params['screen_name'] = options.screenName;
+  }
+  return params;
+}
+
+
+/**
+ * Expose `LinkedInTokenStrategy`.
+ */
+module.exports = LinkedInTokenStrategy;