(function () {

/* Imports */
var Meteor = Package.meteor.Meteor;
var _ = Package.underscore._;
var Random = Package.random.Random;
var check = Package.check.check;
var Match = Package.check.Match;
var WebApp = Package.webapp.WebApp;
var main = Package.webapp.main;
var WebAppInternals = Package.webapp.WebAppInternals;
var Accounts = Package['accounts-base'].Accounts;
var AccountsServer = Package['accounts-base'].AccountsServer;
var OAuth = Package.oauth.OAuth;
var Oauth = Package.oauth.Oauth;

(function(){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                                 //
// packages/accounts-oauth/oauth_common.js                                                                         //
//                                                                                                                 //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                                   //
Accounts.oauth = {};                                                                                               // 1
                                                                                                                   // 2
var services = {};                                                                                                 // 3
                                                                                                                   // 4
// Helper for registering OAuth based accounts packages.                                                           // 5
// On the server, adds an index to the user collection.                                                            // 6
Accounts.oauth.registerService = function (name) {                                                                 // 7
  if (_.has(services, name))                                                                                       // 8
    throw new Error("Duplicate service: " + name);                                                                 // 9
  services[name] = true;                                                                                           // 10
                                                                                                                   // 11
  if (Meteor.server) {                                                                                             // 12
    // Accounts.updateOrCreateUserFromExternalService does a lookup by this id,                                    // 13
    // so this should be a unique index. You might want to add indexes for other                                   // 14
    // fields returned by your service (eg services.github.login) but you can do                                   // 15
    // that in your app.                                                                                           // 16
    Meteor.users._ensureIndex('services.' + name + '.id',                                                          // 17
                              {unique: 1, sparse: 1});                                                             // 18
  }                                                                                                                // 19
};                                                                                                                 // 20
                                                                                                                   // 21
// Removes a previously registered service.                                                                        // 22
// This will disable logging in with this service, and serviceNames() will not                                     // 23
// contain it.                                                                                                     // 24
// It's worth noting that already logged in users will remain logged in unless                                     // 25
// you manually expire their sessions.                                                                             // 26
Accounts.oauth.unregisterService = function (name) {                                                               // 27
  if (!_.has(services, name))                                                                                      // 28
    throw new Error("Service not found: " + name);                                                                 // 29
  delete services[name];                                                                                           // 30
};                                                                                                                 // 31
                                                                                                                   // 32
Accounts.oauth.serviceNames = function () {                                                                        // 33
  return _.keys(services);                                                                                         // 34
};                                                                                                                 // 35
                                                                                                                   // 36
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

}).call(this);






(function(){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                                 //
// packages/accounts-oauth/oauth_server.js                                                                         //
//                                                                                                                 //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                                   //
// Listen to calls to `login` with an oauth option set. This is where                                              // 1
// users actually get logged in to meteor via oauth.                                                               // 2
Accounts.registerLoginHandler(function (options) {                                                                 // 3
  if (!options.oauth)                                                                                              // 4
    return undefined; // don't handle                                                                              // 5
                                                                                                                   // 6
  check(options.oauth, {                                                                                           // 7
    credentialToken: String,                                                                                       // 8
    // When an error occurs while retrieving the access token, we store                                            // 9
    // the error in the pending credentials table, with a secret of                                                // 10
    // null. The client can call the login method with a secret of null                                            // 11
    // to retrieve the error.                                                                                      // 12
    credentialSecret: Match.OneOf(null, String)                                                                    // 13
  });                                                                                                              // 14
                                                                                                                   // 15
  var result = OAuth.retrieveCredential(options.oauth.credentialToken,                                             // 16
                                        options.oauth.credentialSecret);                                           // 17
                                                                                                                   // 18
  if (!result) {                                                                                                   // 19
    // OAuth credentialToken is not recognized, which could be either                                              // 20
    // because the popup was closed by the user before completion, or                                              // 21
    // some sort of error where the oauth provider didn't talk to our                                              // 22
    // server correctly and closed the popup somehow.                                                              // 23
    //                                                                                                             // 24
    // We assume it was user canceled and report it as such, using a                                               // 25
    // numeric code that the client recognizes (XXX this will get                                                  // 26
    // replaced by a symbolic error code at some point                                                             // 27
    // https://trello.com/c/kMkw800Z/53-official-ddp-specification). This                                          // 28
    // will mask failures where things are misconfigured such that the                                             // 29
    // server doesn't see the request but does close the window. This                                              // 30
    // seems unlikely.                                                                                             // 31
    //                                                                                                             // 32
    // XXX we want `type` to be the service name such as "facebook"                                                // 33
    return { type: "oauth",                                                                                        // 34
             error: new Meteor.Error(                                                                              // 35
               Accounts.LoginCancelledError.numericError,                                                          // 36
               "No matching login attempt found") };                                                               // 37
  }                                                                                                                // 38
                                                                                                                   // 39
  if (result instanceof Error)                                                                                     // 40
    // We tried to login, but there was a fatal error. Report it back                                              // 41
    // to the user.                                                                                                // 42
    throw result;                                                                                                  // 43
  else {                                                                                                           // 44
    if (!_.contains(Accounts.oauth.serviceNames(), result.serviceName)) {                                          // 45
      // serviceName was not found in the registered services list.                                                // 46
      // This could happen because the service never registered itself or                                          // 47
      // unregisterService was called on it.                                                                       // 48
      return { type: "oauth",                                                                                      // 49
               error: new Meteor.Error(                                                                            // 50
                 Accounts.LoginCancelledError.numericError,                                                        // 51
                 "No registered oauth service found for: " + result.serviceName) };                                // 52
                                                                                                                   // 53
    }                                                                                                              // 54
    return Accounts.updateOrCreateUserFromExternalService(result.serviceName, result.serviceData, result.options);
  }                                                                                                                // 56
});                                                                                                                // 57
                                                                                                                   // 58
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

}).call(this);


/* Exports */
if (typeof Package === 'undefined') Package = {};
Package['accounts-oauth'] = {};

})();

//# sourceMappingURL=accounts-oauth.js.map