issuer.html/js/playground.js

(function () {
  'use strict';

  window.ngOauth3App = angular.module('oauth3Playground', [ 'oauth3.org' ])
  //window.ngOauth3App = angular.module('oauth3Playground', [ 'ui.router' ])
/*
	ngOauth3App.config(function($stateProvider) {
		var helloState = {
			name: 'hello',
			url: '/hello',
			template: '<h3>hello world!</h3>'
		}

		var aboutState = {
			name: 'about',
			url: '/about',
			template: '<h3>Its the UI-Router hello world app!</h3>'
		}

		$stateProvider.state(helloState);
		$stateProvider.state(aboutState);
	});
*/
	.controller('PlaygroundCtrl', [ '$timeout', 'azp@oauth3.org', function ($timeout, OAUTH3) {
    // NOTE: This OAUTH3 is the same as window.OAUTH3, but with angular's promise injected
    // TODO: how to load more than one version of oauth3 on the page (i.e. a vanilla version without angular entaglement)
		var vm = this;

    vm.framework = 'none';
    vm.clientUri = OAUTH3.clientUri(window.location);
    vm.conf = { debug: undefined, client_id: vm.clientUri, client_uri: vm.clientUri, provider_uri: vm.clientUri };
    vm.providerUri = vm.conf.client_uri;
    // map of things being debounced presently
    vm.debouncing = {};
    vm.defaults = { provider: vm.conf.provider_uri, directives: null };
		vm.defaults.scopes = [
			{ name: 'oauth3_authn', desc: "Basic secure authentication", checked: true }
			//{ name: 'authn@oauth3.org', desc: "Basic secure authentication" }
		, { name: 'photos@daplie.com', desc: "Access to photos" }
		, { name: 'dns', desc: "DNS records (A/AAAA, TXT, SRV, MX, etc)" }
		, { name: '*', desc: "FULL ACCOUNT ACCESS" }
		];

    vm.form = {};
    vm.form.id = 'coolaj86@gmail.com';
    vm.form.subject = '';
    vm.form.userProvider = '';
    vm.form.provider = 'sso.hellabit.com';
    vm.form.scopes = '';

    vm.locks = {};
    vm.validated = {};
    vm.responses = {};

    //
    // Convenience for our app
    //
    vm.fn = {};
    vm.fn._debounce = {};
    vm.fn.debounceUi = function () {
      if (vm.debouncing.user || vm.debouncing.provider) {
        vm.locks['login'] = true;
      } else {
        vm.locks['login'] = false;
      }
    };
    vm.fn.debounce = function (name, time) {
      vm.debouncing[name] = true;
      vm.fn.debounceUi();
      $timeout.cancel(vm.fn._debounce[name]);
      vm.fn._debounce[name] = $timeout(function () {
        vm.debouncing[name] = false;
        vm.fn.debounceUi();
        // do nothing, just use promise
        return;
      }, time || 250);
      return vm.fn._debounce[name];
    }
    vm.fn.changeUser = function () {
      var parts = vm.form.id.split('@');
      var user;
      var provider;

      if (/@/.test(vm.form.id)) {
        // The username may have a single @, the provider may not
        // user@thing.com@whatever.com -> user@thing.com, whatever.com
        provider = parts.pop();
        user = parts.join('');
      } else {
        //vm.form.hasUser = false;
        user = '';
        provider = parts.join('');
      }

      vm.form.subject = vm.form.id;

      return vm.fn.debounce('provider', 250).then(function () {
        var parts = vm.form.provider.split('.');
        if (!vm.form.providerIndependent) {
          vm.form.provider = provider;
        }
        vm.form.userProvider = provider;
        // Careful: don't use state within a debounce function
        // uses vm.form.provider for lookup
        if (parts.length >= 2 && parts[parts.length - 1].length >= 2 && parts.every(function (p) {return p.length})) {
          return vm.api.discover().then(function () {
            console.log('[changeUser] vm.directives:');
            console.log(vm.directives);
            console.log(provider);
            console.log(OAUTH3.uri.normalize(vm.directives.issuer));
            if (vm.directives && provider === OAUTH3.uri.normalize(vm.directives.issuer)) {
              vm.form.subject = user;
            } else {
              vm.form.subject = vm.form.id;
            }
          });
        }
      });
    };
    vm.fn.changeProvider = function () {
      vm.form.providerIndependent = true;

      var parts = vm.form.provider.split('.');
      vm.fn.debounce('provider', 250).then(function () {
        // Careful: don't use state within a debounce function
        if (parts.length >= 2 && parts[parts.length - 1].length >= 2 && parts.every(function (p) {return p.length})) {
          return vm.api.discover();
        }
      });
    };
    vm.fn.toggleAdvanced = function () {
      vm.advanced = !vm.advanced;
      vm.form.provider = vm.form.userProvider;
      if (!vm.advanced) {
        vm.form.providerIndependent = false;
        vm.fn.changeUser();
      }
    };
    vm.fn.updateDebug = function () {
      if (!vm.conf.debug) {
        vm.conf.debug = undefined;
      }
    };
    vm.fn.updateScopes = function () {
      var scopes = {};

      (vm.scopes && vm.scopes.split(',') || []).forEach(function (name) {
        scopes[name] = true;
      });

      vm.defaults.scopes.forEach(function (scope) {
        if (scope.checked) {
          scopes[scope.name] = true;
        } else {
          scopes[scope.name] = false;
        }
      });

      vm.form.scopes = Object.keys(scopes).filter(function (key) {
        return scopes[key];
      }).map(function (key) {
        return key;
      }).join(',');

      vm.api.urls.implicitGrant();
    };

    vm.fn.lock = function () {
      vm._working = true;
    };
    vm.fn.unlock = function () {
      vm._working = false;
    };
    vm.fn.clearError = function () {
      vm.error = null;
    };
    vm.fn.clearDirectives = function () {
      vm.directives = null;
    };

    // A place for all the generated urls
    vm.urls = {};

    //
    // Wrap around the OAUTH3 APIs
    //
    vm.api = {};
    vm.api.urls = {};
    vm.api.authn = {};
    vm.api.jwt = {};
    vm.api.urls.credentialMeta = function () {
      vm.urls.credentialMeta = OAUTH3.urls.credentialMeta(vm.directives, { email: vm.form.id });
    };
    vm.api.urls.otp = function () {
      vm.urls.otp = OAUTH3.urls.otp(vm.directives, { email: vm.form.id });
    };
    vm.api.authn.otp = function () {
      vm.api.urls.otp();
      OAUTH3.authn.otp(vm.directives, { email: vm.form.id }).then(function (resp) {
        vm.responses.otp = resp;
        vm.form.otpUuid = resp.data.code_id;
        console.log('vm.responses.otp: (' + typeof resp + ')');
        console.log(vm.responses.otp);

        console.log('vm.form.otpUuid:');
        console.log(vm.form.otpUuid);

        vm.api.urls.resourceOwnerPassword();
      });
    };
    vm.api.authn.credentialMeta = function () {
      vm.api.urls.credentialMeta();
      OAUTH3.authn.loginMeta(vm.directives, { email: vm.form.id });
    };


    vm.api.authn._ropOpts = function () {
      //var opts = { email: vm.form.id, uuid: vm.form.otpUuid, code: vm.form.otpCode };
      return vm.api.authn._ropOpts_ = {
        client_id: vm.conf.client_uid || undefined
      , client_uri: vm.conf.client_uri || undefined
      , grant_type: 'password'
      , username: vm.form.id || undefined
      , password: vm.form.otpCode || undefined
      , totp: vm.form.totpToken || undefined
      , otp: vm.form.otpCode || "{{otp-code}}"
      , password_type: vm.form.otpCode && 'otp' || undefined
      , otp_code: vm.form.otpCode || undefined
      , otp_id: vm.form.otpUuid || undefined
      , otp_uuid: vm.form.otpUuid || undefined
      , user_agent: navigator.userAgent || undefined // "AJ's Macbook" for a specific device?
      , jwk: vm.form.rememberDevice && opts.jwk || undefined
      //, "public_key": opts.rememberDevice && opts.publicKey || undefined
      //, "public_key_type":  opts.rememberDevice && opts.publicKeyType || undefined // RSA/ECDSA
      //, "jwt": opts.jwt // TODO sign a proof with a previously loaded public_key
      , debug: vm.form.debug || undefined
      };
    };
    vm.api.urls.resourceOwnerPassword = function () {
      vm.urls.resourceOwnerPassword = OAUTH3.urls.resourceOwnerPassword(vm.directives, vm.api.authn._ropOpts());
    };
    vm.api.authn.resourceOwnerPassword = function () {
      vm.api.urls.resourceOwnerPassword();
      OAUTH3.authn.resourceOwnerPassword(vm.directives, vm.api.authn._ropOpts()).then(function (resp) {
        vm.responses.resourceOwnerPassword = { status: 0, data: resp };
        vm.form.accessToken = vm.accessToken = resp.access_token;
        vm.form.refreshToken = vm.refreshToken = resp.refresh_token;
        vm.ropSession = resp.token;
      });
    };


    vm.api.jwt.decode = function () {
      vm.ropSession = OAUTH3.jwt.decode(vm.form.accessToken || vm.accessToken);
    };
    vm.api.jwt.decodeRefresh = function () {
      vm.ropSession = OAUTH3.jwt.decode(vm.form.refreshToken || vm.refreshToken);
    };

    vm.api.providerUri = function () {
      console.log('[DEBUG] providerUri:', vm.providerUri);
      try {
        vm.providerUri = OAUTH3.uri.normalize(vm.providerUri);
        vm.conf.provider_uri = vm.providerUri;
      } catch(e) {
        vm.error = e;
      }
    };
    vm.api.clientUri = function () {
      console.log('[DEBUG] clientUri:', vm.clientUri);
      try {
        vm.clientUri = OAUTH3.clientUri({ host: vm.clientUri });
        if (vm.clientUri) {
      console.log('[DEBUG] clientUri:', vm.clientUri);
          vm.conf.client_uri = vm.clientUri;
          vm.conf.client_id = vm.clientUri;
        }
      } catch(e) {
        vm.error = e;
      }
    };
    vm.api._discoverCount = 0;
    vm.api.urls.implicitGrant = function (provider) {
      if (!vm.directives) {
        console.log('[DEBUG] skipping implicit grant due to missing directives');
        return;
      }
      var opts = {
        client_uri: vm.conf.client_uri
      , subject: vm.form.subject || undefined
      , debug: vm.conf.debug || undefined
      , scope: vm.form.scopes || undefined
      };
      var implicitGrantObj = OAUTH3.urls.implicitGrant(vm.directives, opts);
      vm.implicitGrantUrl = (OAUTH3.url.normalize(provider || vm.form.provider) + '/' + implicitGrantObj.url).replace(implicitGrantObj.state, '{{random}}');
    }
    vm.api.discover = function () {
      vm.directives = null;
      vm.validated.provider = '';
      vm.api._discoverCount += 1;
      var latest = vm.api._discoverCount;
      var provider = vm.form.provider; // shouldn't be mutable during this time but...

      vm.fn.lock();

      vm.discoveryObj = OAUTH3.urls.discover(provider, vm.conf);
      vm.directivesUrl = OAUTH3.url.normalize(provider) + '/' + vm.discoveryObj.query._pathname;
      vm.discoveryUrl = vm.discoveryObj.method + ' ' + vm.discoveryObj.url;

      console.log('about to discover');

      return OAUTH3.discover(provider, vm.conf).then(function (dir) {
        if (latest !== vm.api._discoverCount) {
          console.log('[DEBUG] ignoring stale discover response for', provider);
          return;
        }
        console.log('[DEBUG] directives:');
        console.log(dir);
        vm.validated.provider = provider;
        vm.directives = dir;

        vm.api.urls.implicitGrant(provider);
        //JSON.stringify(dir, null, 2);
      }, function (err) {
        vm.form.provider = vm.defaults.provider;
        vm.validated.provider = vm.defaults.provider;
        vm.directives = vm.defaults.directives;
        if (latest !== vm.api._discoverCount) {
          console.warn('[DEBUG] ignoring stale discover error for', provider);
          console.warn(err);
          return;
        }
        console.log('error on discover');
        vm.error = err;
      }).then(function () {
        vm.fn.unlock();
      });
    };
    vm.api.discoverScopes = function () {
      var scopes = vm.form.scopes && vm.form.scopes.split(',') || [];
      vm.scopesObj = [];

      function nextScope() {
        var scopename = scopes.shift();
        if (!scopename) {
          return;
        }

        // something like https://example.com/.well-known/oauth3.org/scopes/:scopename.json
        var scopeUrlObj = OAUTH3.urls.discoverScope(vm.form.provider, {
          client_uri: vm.conf.client_uri
        , scope: scopename
        , debug: vm.conf.debug || undefined
        });
        vm.scopeUrl = OAUTH3.url.normalize(provider) + '/' + scopeUrlObj.query._pathname;

        // something like the discovery url that loads in an iframe
        var discoverScopeObj = OAUTH3.urls.discoverScope(vm.form.provider, {
          client_uri: vm.conf.client_uri
        , scope: scopename
        , debug: vm.conf.debug || undefined
        });
        vm.discoverScopeUrl = OAUTH3.url.normalize(provider) + '/' + discoverScopeObj.url;

        // Go and fetch!
        return OAUTH3.discoverScopes(vm.form.provider, {
          client_uri: vm.conf.client_uri
        , scope: scopename
        , debug: vm.conf.debug || undefined
        }).then(function (scope) {
          var allScopes = {};
          vm.scopesObj.push(scope);
          vm.defaults.scopes.push(scope);
          vm.defaults.scopes = vm.defaults.scopes.filter(function (scope) {
            if (allScopes[scope.name]) {
              return false;
            }
            allScopes[scope.name] = true;
            return true;
          });
        }, function (err) {
          console.error("Error in discover scope:");
          console.error(err);
          vm.scopesObj.push({ name: scopename, desc: "Error, not found" });
        });
      }

      return nextScope();
    };
    vm.api.implicitGrant = function () {
      var provider = vm.validated.provider;
      var opts = {
        client_uri: vm.conf.client_uri
      , subject: vm.form.subject || undefined
      , debug: vm.conf.debug || undefined
      , scope: vm.form.scopes || undefined
      };

      console.log('[DEBUG] vm.directives');
      console.log(vm.directives);
      vm.implicitGrantObj = OAUTH3.urls.implicitGrant(vm.directives, opts);
      console.log('[DEBUG] vm.implicitGrantObj');
      console.log(vm.implicitGrantObj);
      vm.implicitGrantUrl = (OAUTH3.url.normalize(provider) + '/' + vm.implicitGrantObj.url);
      return OAUTH3.implicitGrant(vm.directives, opts).then(function (session) {
        vm.session = session;
      });
    };

    vm.form.provider = vm.defaults.provider;
    vm.validated.provider = vm.defaults.provider;
    vm.api.discover().then(function () {
      vm.defaults.directives = vm.directives;
    });

    vm.fn.updateScopes();
	} ] );
}());