def register():
    current_user = User.getCurrentUser()
    if current_user is None:
        return redirect(url_for('frontend.index'))

    if request.method == 'GET':
        return render_template('app/register.html')

    elif request.method == 'POST':
        req_fields = ['name', 'host_url', 'redirect_uris', 'scopes']
        for field in req_fields:
            if not request.form.get(field):
                abort(404)

        new_app = Client(
            id=gen_salt(40),
            client_secret=gen_salt(50),
            name=request.form.get('name'),
            description=request.form.get('desc'),
            user_id=current_user.id,
            _host_url=request.form.get('host_url'),
            _redirect_uris=urlnorm(request.form.get('redirect_uris')),
            _default_scopes=' '.join(request.form.get('scopes').split(',')),
            _is_private=False
        )
        new_app.persist()

        return redirect(url_for('user.myApps'))

def client():
    user = current_user()
    if not user:
        # session['id'] = 1  # temporary decision
        return redirect(url_for('register'))

    item = Client(
        client_id=gen_salt(40),
        client_secret=gen_salt(50),
        _redirect_uris=' '.join([
            '%s/%s' % (settings.BASE_URL, 'authorized'),
            'http://localhost:8000/authorized',
            'http://127.0.0.1:8000/authorized',
            'http://127.0.1:8000/authorized',
            'http://127.1:8000/authorized',
            ]),
        _default_scopes='email',
        user_id=session['id'],
    )

    db.session.add(item)
    db.session.commit()

    return jsonify(
        client_id=item.client_id,
        client_secret=item.client_secret,
    )

 def __init__(self, user, redirect_uris, realms, client_key=None, client_secret=None):
     assert isinstance(user, User), "user = {!r}, of type {}".format(user, type(user))
     self.user = user
     self.redirect_uris = redirect_uris
     self.client_key = client_key or gen_salt(30)
     self.client_secret = client_secret or gen_salt(40)
     self.realms = list(realms)

def add_client():
    if request.method == 'POST':
        user = current_user()
        scopes = 'general'

        if user['authority'] == 'Admin':
            scopes = 'general inhabitant admin'
        elif user['authority'] == 'Inhabitant':
            scopes = 'general inhabitant'

        client = Client(
            name = request.form['name'],
            client_id = gen_salt(40),
            client_secret = gen_salt(50),
            user_id = current_user()['id'],
            raw_redirect_uris = request.form['redirect_uri'],
            raw_default_scopes=scopes,
        )

        db.session.add(client)
        db.session.commit()
    else:
        return render_template('add_client.html')

    return redirect(url_for('clients'))

def challenge():
  uuid = request.args.get('uuid')
  session = ws.hashlib.sha256(SESSION_SECRET + uuid).hexdigest()
  session_challenge = session + "_challenge"
  session_pow_challenge = session + "_pow_challenge"

  if session_pow_challenge in session_store:
    session_store.delete(session_pow_challenge)

  if session_challenge in session_store:
    session_store.delete(session_challenge)

  salt = ws.hashlib.sha256(SERVER_SECRET + uuid).hexdigest()
  pow_challenge = ws.gen_salt(32)
  challenge = ws.gen_salt(32)

  session_store.put(session_pow_challenge, pow_challenge)
  session_store.put(session_challenge, challenge)
  print session_challenge
  response = {
      'salt': salt,
      'pow_challenge': pow_challenge,
      'challenge': challenge
  }

  return jsonify(response)

 def generate_api_token(self):
     token = security.gen_salt(40)
     while Account.query.filter_by(api_token=token).count():
         token = security.gen_salt(40)
     self.api_token = token
     self.save()
     return self

def test_auth():
    """
    A route for authenticating a user (OAuth), for testing.
    """
    user_id = request.form['id']

    client = Client(
        client_id=gen_salt(40),
        client_secret=gen_salt(50),
        _redirect_uris='http://localhost:5000/authorized',
        _default_scopes='userinfo',
        _allowed_grant_types='authorization_code refresh_token',
        user_id=user_id,
    )
    db.session.add(client)

    token = Token(
        access_token=gen_salt(40),
        refresh_token=gen_salt(40),
        token_type='authorization_code',
        _scopes='userinfo',
        expires=datetime.max,
        client_id=client.client_id,
        user_id=user_id
    )
    db.session.add(token)
    db.session.commit()
    return jsonify(token=token.access_token)

def challenge():
  validate_uuid = UUID(request.args.get('uuid'))
  uuid = str(validate_uuid)
  session = ws.hashlib.sha256(config.SESSION_SECRET + uuid).hexdigest()
  salt = ws.hashlib.sha256(config.SERVER_SECRET + uuid).hexdigest()
  pow_challenge = ws.gen_salt(32)
  challenge = ws.gen_salt(32)

  if config.LOCALDEVBYPASSDB:
    session_challenge = session + "_challenge"
    session_pow_challenge = session + "_pow_challenge"

    if session_pow_challenge in session_store:
      session_store.delete(session_pow_challenge)

    if session_challenge in session_store:
      session_store.delete(session_challenge)

    session_store.put(session_pow_challenge, pow_challenge)
    session_store.put(session_challenge, challenge)
  else:
    dbExecute("with upsert as (update sessions set challenge=%s, pchallenge=%s, timestamp=DEFAULT where sessionid=%s returning *) "
              "insert into sessions (sessionid, challenge, pchallenge) select %s,%s,%s where not exists (select * from upsert)", 
              (challenge, pow_challenge, session, session, challenge, pow_challenge))
    dbCommit()
    
  response = {
      'salt': salt,
      'pow_challenge': pow_challenge,
      'challenge': challenge
  }

  return jsonify(response)

def register():
	logger.debug(" in register session[id] is %s", session['id'])
	user = current_user()
	
	if request.method == 'GET':
		return render_template('register.html', user=user)
	if request.method == 'POST':
		applicationName = request.form.get('applicationName')
		applicationUrl = request.form.get('applicationUrl')
		applcationDescription=request.form.get('applcationDescription')
		applicationCallbackUrl=request.form.get('applicationCallbackUrl')
		userId=request.form.get('userId')
		item = Client(
        client_id=gen_salt(40),
        client_secret=gen_salt(50),
        application_name=applicationName,
        application_url=applicationUrl,
        _redirect_uris=' '.join([
        	applicationCallbackUrl,
            ]),
        _default_scopes='email',
        user_id=userId,
    	)
		from pprint import pprint
		pprint (vars(item))
        db.session.add(item)
        db.session.commit()
        
    	return jsonify(
        client_id=item.client_id,
        client_secret=item.client_secret,
        )

    def get(self, *args, **kwargs):
        user = self.current_user()

        if not user:
            return self.redirect_view('home')

        client = models.Client(
            client_id=gen_salt(40),
            client_secret=gen_salt(50),
            _redirect_uris=' '.join([
                'http://localhost:8000/authorized/',
                'http://127.0.0.1:8000/authorized/',
                'http://127.0.1:8000/authorized/',
                'http://127.1:8000/authorized/',
            ]),
            _default_scopes='email',
            user_id=user.id,
        )

        db.session.add(client)
        db.session.commit()

        return self.jsonify({
            'client_id': client.client_id,
            'client_secret': client.client_secret,
        })

 def createAccessToken(self, SESSION):
     '''
     Creates an access token for this client.
     '''
     token = gen_salt(25)
     secret = gen_salt(25)
     return AccessToken(self, self.user, token, secret, self._realms)    

def client():
    """
    This endpoint creates and provides the authenticated user with
    ``client_id`` and ``client_secret``.
    """
    if not current_user.is_authenticated:
        return api.abort(code=http_exceptions.Unauthorized.code)
    # XXX: remove hard-codings
    # TODO: reconsider using gen_salt
    # TODO: develop sensible scopes
    # TODO: consider moving `db` operations into OAuth2Client class implementation
    client_instance = OAuth2Client(
        client_id=security.gen_salt(40),
        client_secret=security.gen_salt(50),
        _redirect_uris=" ".join(
            [
                "http://localhost:8000/authorized",
                "http://127.0.0.1:8000/authorized",
                "http://127.0.0.1:5000/api/v1/o2c.html",
                "http://127.0.0.2:8000/authorized",
                "http://127.0.1:8000/authorized",
                "http://127.1:8000/authorized",
            ]
        ),
        _default_scopes="users:read users:write email",
        user_id=current_user.id,
    )
    db.session.add(client_instance)
    db.session.commit()
    return jsonify(client_id=client_instance.client_id, client_secret=client_instance.client_secret)

    def bootstrap_user():
        """
        Return or create a OAuthClient owned by the authenticated real user.
        Re-uses an existing client if "oauth_client" is found in the database
        for this user, otherwise writes a new client to the database.

        Similar logic performed for the OAuthToken.

        :return: OAuthToken instance
        """
        assert current_user.email != current_app.config['BOOTSTRAP_USER_EMAIL']

        uid = current_user.get_id()
        client_name = current_app.config.get('BOOTSTRAP_CLIENT_NAME', 'BB client')

        client = OAuthClient.query.filter_by(
            user_id=uid,
            name=client_name,
        ).first()

        if client is None:
            scopes = ' '.join(current_app.config['USER_DEFAULT_SCOPES'])
            salt_length = current_app.config.get('OAUTH2_CLIENT_ID_SALT_LEN', 40)
            client = OAuthClient(
                user_id=current_user.get_id(),
                name=client_name,
                description=client_name,
                is_confidential=True,
                is_internal=True,
                _default_scopes=scopes,
            )
            client.gen_salt()
            db.session.add(client)

            token = OAuthToken(
                client_id=client.client_id,
                user_id=uid,
                access_token=gen_salt(salt_length),
                refresh_token=gen_salt(salt_length),
                expires=datetime.datetime(2500, 1, 1),
                _scopes=scopes,
                is_personal=False,
                is_internal=True,
            )
            db.session.add(token)
            db.session.commit()
            current_app.logger.info(
                "Created BB client for {email}".format(email=current_user.email)
            )
        else:
            token = OAuthToken.query.filter_by(
                client_id=client.client_id,
                user_id=current_user.get_id(),
            ).first()

        return client, token

def client():
    item = Client(
            client_id=gen_salt(40),
            client_secret=gen_salt(50),
            _redirect_uris='/',
            is_confidential=True
    )
    db.session.add(item)
    db.session.commit()
    return make_response(json.dumps(item.dict()), 200)

    def generate(redirect_uris):

        item = Client(
            client_id=gen_salt(40),
            client_secret=gen_salt(50),
            _redirect_uris=" ".join(redirect_uris),
            _default_scopes="email",
            user_id=None,
        )
        item.save()

def login(provider):
    if provider == "dgfr":
        remote_app = dgfr
    else:
        abort(400, 'Unknown login provider')
    return remote_app.authorize(
        callback=url_for('authorized', provider=provider, _external=True),
        state=security.gen_salt(10),
        nonce=security.gen_salt(10),
    )

 def get_authorized_header(self, user_id=1, scope=""):
     # prepare token
     token = OAuthToken(
         access_token=gen_salt(10), refresh_token=gen_salt(10), token_type="Bearer", scope=scope, expires_in=3600
     )
     token.user_id = user_id
     token.client_id = 1
     db.session.add(token)
     db.session.commit()
     return {"Authorization": "Bearer %s" % token.access_token, "Content-Type": "application/json"}

 def create_user(self, username=None):
     username = username or gen_salt(6)
     user = User()
     user.douban_uid = username
     user.douban_name = username
     user.douban_id = random.randint(1, 1000)
     user.douban_access_token = gen_salt(32)
     user.douban_refresh_token = gen_salt(32)
     db.session.add(user)
     db.session.commit()
     return user

 def create(cls, name, redirect_uris, default_scopes):
     client = cls(
         name=name,
         client_id=gen_salt(40),
         client_secret=gen_salt(60),
         _redirect_uris=' '.join(redirect_uris),
         _default_scopes=' '.join(default_scopes)
     )
     db.session.add(client)
     db.session.commit()
     return client

def reset_api_key():
    client = Client.query.filter_by(client_id=request.form['id']).first()
    if client is None:
        return ('ID Not Found', 500)

    client.client_id = gen_salt(40)
    client.client_secret = gen_salt(50)

    db.session.add(client)
    db.session.commit()

    return redirect(url_for('clients'))