def authorize(self): if request.method == u"POST": token = request.form.get("oauth_token") return self.authorized(token) else: token = request.args.get(u"oauth_token", None) if token is None: return "oauth_token required", 400 req_token = RequestToken.query( RequestToken.token == token).get() if req_token is None: # Joskus App Enginen datastore ei pysy OAuth-prosessin # tahdissa mukana: time.sleep(2) req_token = RequestToken.query( RequestToken.token == token).get() if req_token is None: return "request token not found", 503 client = req_token.client.get() return render_template( u"authorize.html", token=token, req_token=req_token, client=client)
def start_authorizing(request, key): """Get the initial access token and send the user to authorize it""" prosthetic = get_object_or_404(Prosthetic, id=key) wrangler = prosthetic.wrangler() try: token = wrangler.get_request_token() # Save the token ready for the callback try: token = RequestToken.objects.get(oauth_key=token.key) logging.error("request token for key already exists!") token.delete() except RequestToken.DoesNotExist: pass request_token = RequestToken(oauth_key=token.key, oauth_secret=token.secret, prosthetic=prosthetic) request_token.save() callback_url = "http://%s/oauth_callback/" % settings.LOCAL_SERVER start = wrangler.authorize_request_token_url(token, callback_url) return redirect(start) except urlfetch.DownloadError, e: return render_error(request, "Can't connect to API server: %s" % (e))
def save_request_token(self, client_key, request_token, callback, realm=None, secret=None): client = Client.find_one({'client_key':client_key}) if client: token = RequestToken( request_token, callback, secret=secret, realm=realm) token.client_id = client['_id'] RequestToken.insert(token)
def save_request_token(self, client_key, request_token, callback, realm=None, secret=None): client = Client.query(Client.client_key == client_key).get() if client: token = RequestToken( token=request_token, callback=callback, secret=secret, realm=realm, client=client.key) token.put()
def save_request_token(self, client_key, request_token, callback, realm=None, secret=None): token = RequestToken(request_token, callback, secret=secret, realm=realm) token.client = Client.query.filter_by(client_key=client_key).one() db_session.add(token) db_session.commit()
def validate_request_token(self, client_key, resource_owner_key): token = None if client_key: client = Client.query(Client.client_key == client_key).get() if client: token = RequestToken.query( RequestToken.token == resource_owner_key, RequestToken.client == client.key).get() else: token = RequestToken.query( RequestToken.token == resource_owner_key).get() return token is not None
def save_request_token(self, client_key, request_token, callback, realm=None, secret=None): client = Client.query(Client.client_key == client_key).get() if client: token = RequestToken(token=request_token, callback=callback, secret=secret, realm=realm, client=client.key) token.put()
def get_callback(self, request_token): token = RequestToken.query(RequestToken.token == request_token).get() if token: return token.callback else: return None
def save_request_token(self, client_key, request_token, callback, realm=None, secret=None): client = Client.find_one({'client_key': client_key}) if client: token = RequestToken(request_token, callback, secret=secret, realm=realm) token.client_id = client['_id'] RequestToken.insert(token)
def get(self): request_token_key = self.request.get("oauth_token") request_verifier = self.request.get('oauth_verifier') if not request_token_key: self.redirect('/') return request_token = RequestToken.gql("WHERE token_key=:1", request_token_key).get() request_token.key.delete() auth = tweepy.OAuthHandler(Const.CONSUMER_KEY, Const.CONSUMER_SECRET) auth.set_request_token(request_token.token_key, request_token.token_secret) access_token = auth.get_access_token(request_verifier) cookie = get_cookie() memcache.set(cookie['sid'].value, access_token, SESSION_EXPIRE) #@UndefinedVariable twitter_user = get_twitter_data(cookie) user = User.get_or_insert(User.create_key(twitter_user['id']), userId=twitter_user['id']) user.accessToken = access_token.key user.accessSecret = access_token.secret user.screenName=twitter_user['screen_name'] user.image=twitter_user['profile_image_url'] user.put() self.redirect('/')
def save_access_token(self, client_key, access_token, request_token, realm=None, secret=None): client = Client.find_one({'client_key': client_key}) if client: req_token = RequestToken.find_one({'token': request_token}, as_obj=True) if req_token: if not req_token['user_id']: req_token['user_id'] = current_user.get_id() req_token.save() token = AccessToken.find_or_create( client_id=client['_id'], user_id=req_token['user_id'], #current_user.get_id(), realm=realm if realm else req_token['realm']) token.secret = secret token.token = access_token token.save()
def validate_request_token(self, client_key, resource_owner_key): # TODO: make client_key optional token = None if client_key: client = Client.find_one({'client_key':client_key}) if client: token = RequestToken.find_one( {'token':access_token, 'client_id': client['_id']}) else: token = RequestToken.find_one( {'token':resource_owner_key}) return token != None
def authorize(self): if request.method == u"POST" or 'done' in request.args: token = request.form.get("oauth_token") if not token: token = request.args.get("oauth_token") return self.authorized(token, request = request) else: # TODO: Authenticate client token_key = request.args.get(u"oauth_token") token = RequestToken.find_one({'token': token_key}) if token: realm = token.get('realm') # TODO: Make this more robust. session['realm'] = realm if realm and realm in APIS: #url = ("%s?first_oauth_token=%s" % # (url_for('%s.finished' % realm, _external = True), token_key)) session['original_token'] = token_key url = url_for('%s.finished' % realm, _external = True) resp = APIS[realm].authorize( callback = url, **APIS[realm].auth_params) return resp return render_template(u"authorize.html", token=token_key, realm = token['realm'].title()) # If we got here, it's because we don't recognize the client attempting # to connect. Send them an "unauthorized" error. abort(403)
def get_callback(self, request_token): token = RequestToken.find_one({'token': request_token}) if token: return token.get('callback') else: return None
def get_callback(self, request_token): token = RequestToken.find_one( {'token':request_token}) if token: return token.get('callback') else: return None
def validate_request_token(self, client_key, resource_owner_key): # TODO: make client_key optional token = None if client_key: client = Client.find_one({'client_key': client_key}) if client: token = RequestToken.find_one({ 'token': access_token, 'client_id': client['_id'] }) else: token = RequestToken.find_one({'token': resource_owner_key}) return token != None
def get_realm(self, client_key, request_token): client = Client.find_one({'client_key':client_key}) if client: return RequestToken.find_one( {'token':request_token, 'client_id': client['_id']})['realm'] else: return None
def get_realm(self, client_key, request_token): client = Client.find_one({'client_key': client_key}) if client: return RequestToken.find_one({ 'token': request_token, 'client_id': client['_id'] })['realm'] else: return None
def validate_verifier(self, client_key, resource_owner_key, verifier): token = None client = Client.query(Client.client_key == client_key).get() if client: token = RequestToken.query( RequestToken.client == client.key, RequestToken.token == resource_owner_key, RequestToken.verifier == verifier).get() return token is not None
def get_realm(self, client_key, request_token): client = Client.find_one({'client_key':client_key}) if client: token = RequestToken.find_one( {'token':request_token, 'client_id': client['_id']}) if token: return token.get('realm') return None
def validate_verifier(self, client_key, resource_owner_key, verifier): token = None client = Client.find_one({'client_key':client_key}) if client: token = RequestToken.find_one( {'token':resource_owner_key, 'client_id': client['_id'], 'verifier':verifier}) return token != None
def save_request_token(self, client_key, request_token, callback, realm=None, secret=None): client = Client.find_one({'client_key':client_key}) if client: token = RequestToken.find_or_create(realm = realm, user_id = current_user.get_id(), client_id = client['_id']) token.token = request_token token.callback = callback token.secret = secret token.save()
def validate_verifier(self, client_key, resource_owner_key, verifier): token = None client = Client.find_one({'client_key': client_key}) if client: token = RequestToken.find_one({ 'token': resource_owner_key, 'client_id': client['_id'], 'verifier': verifier }) return token != None
def get_realm(self, client_key, request_token): client = Client.query(Client.client_key == client_key).get() if client: token = RequestToken.query( RequestToken.token == request_token, RequestToken.client == client.key).get() if token: return token.realm return None
def get_request_token_secret(self, client_key, resource_owner_key): client = Client.query(Client.client_key == client_key).get() if client: token = RequestToken.query( RequestToken.client == client.key, RequestToken.token == resource_owner_key).get() if token: return token.secret return None
def validate_timestamp_and_nonce(self, client_key, timestamp, nonce, request_token=None, access_token=None): token = True req_token = True client = Client.find_one({'client_key':client_key}) if client: nonce = Nonce.find_one({'nonce':nonce, 'timestamp':timestamp, 'client_id':client['_id']}) if nonce: if request_token: req_token = RequestToken.find_one( {'_id':nonce['request_token_id'], 'token':request_token}) if access_token: token = RequestToken.find_one( {'_id':nonce['request_token_id'], 'token':access_token}) return token and req_token and nonce != None
def get_request_token_secret(self, client_key, resource_owner_key): client = Client.find_one({'client_key':client_key}) if client: token = RequestToken.find_one( {'token':resource_owner_key, 'client_id': client['_id']}) if token: return token['secret'] return None
def get_request_token_secret(self, client_key, resource_owner_key): client = Client.find_one({'client_key': client_key}) if client: token = RequestToken.find_one({ 'token': resource_owner_key, 'client_id': client['_id'] }) if token: return token['secret'] return None
def get_realm(self, client_key, request_token): client = Client.find_one({'client_key': client_key}) if client: token = RequestToken.find_one({ 'token': request_token, 'client_id': client['_id'] }) if token: return token.get('realm') return None
def save_request_token(token, req): assert isinstance(req, oauthlib.common.Request) rt = token['oauth_token'] rts = token['oauth_token_secret'] client = req.client assert type(client) is Client, type(client) assert isinstance(req.redirect_uri, str) # py3 t = RequestToken(client=req.client, token=rt, secret=rts, redirect_uri=req.redirect_uri, realms=client.default_realms) # ?? request_tokens.append(t)
def save_access_token(self, client_key, access_token, request_token, secret=None): client = Client.query(Client.client_key == client_key).get() req_token = RequestToken.query( RequestToken.token == request_token).get() if client and req_token: token = AccessToken( token=access_token, secret=secret, client=client.key, resource_owner=req_token.resource_owner, realm=req_token.realm) token.put()
def save_access_token(self, client_key, access_token, request_token, realm=None, secret=None): client = Client.find_one({'client_key':client_key}) if client: token = AccessToken(access_token, secret=secret, realm=realm) token.client_id = client['_id'] req_token = RequestToken.find_one({'token':request_token}) if req_token: token['resource_owner_id'] = req_token['resource_owner_id'] token['realm'] = req_token['realm'] AccessToken.insert(token)
def authorize(self): if request.method == u"POST": token = request.form.get("oauth_token") return self.authorized(token) else: token = request.args.get(u"oauth_token", None) if token is None: return "oauth_token required", 400 req_token = RequestToken.query(RequestToken.token == token).get() if req_token is None: # Joskus App Enginen datastore ei pysy OAuth-prosessin # tahdissa mukana: time.sleep(2) req_token = RequestToken.query( RequestToken.token == token).get() if req_token is None: return "request token not found", 503 client = req_token.client.get() return render_template(u"authorize.html", token=token, req_token=req_token, client=client)
def validate_timestamp_and_nonce(self, client_key, timestamp, nonce, request_token=None, access_token=None): token = True req_token = True client = Client.find_one({'client_key': client_key}) if client: nonce = Nonce.find_one({ 'nonce': nonce, 'timestamp': timestamp, 'client_id': client['_id'] }) if nonce: if request_token: req_token = RequestToken.find_one({ '_id': nonce['request_token_id'], 'token': request_token }) if access_token: token = RequestToken.find_one({ '_id': nonce['request_token_id'], 'token': access_token }) return token and req_token and nonce != None
def save_request_token(self, client_key, request_token, callback, realm=None, secret=None): client = Client.find_one({'client_key': client_key}) if client: token = RequestToken.find_or_create(realm=realm, user_id=current_user.get_id(), client_id=client['_id']) token.token = request_token token.callback = callback token.secret = secret token.save()
def save_access_token(self, client_key, access_token, request_token, secret=None): client = Client.query(Client.client_key == client_key).get() req_token = RequestToken.query( RequestToken.token == request_token).get() if client and req_token: token = AccessToken(token=access_token, secret=secret, client=client.key, resource_owner=req_token.resource_owner, realm=req_token.realm) token.put()
def save_timestamp_and_nonce(self, client_key, timestamp, nonce, request_token=None, access_token=None): client = Client.find_one({'client_key':client_key}) if client: nonce = Nonce(nonce, timestamp) nonce.client_id = client['_id'] if request_token: req_token = RequestToken.find_one({'token':request_token}) nonce.request_token_id = req_token['_id'] if access_token: token = AccessToken.find_one({'token':access_token}) nonce.access_token_id = token['_id'] nonce.insert()
def save_access_token(self, client_key, access_token, request_token, realm=None, secret=None): client = Client.find_one({'client_key': client_key}) if client: token = AccessToken(access_token, secret=secret, realm=realm) token.client_id = client['_id'] req_token = RequestToken.find_one({'token': request_token}) if req_token: token['resource_owner_id'] = req_token['resource_owner_id'] token['realm'] = req_token['realm'] AccessToken.insert(token)
def save_timestamp_and_nonce(self, client_key, timestamp, nonce, request_token=None, access_token=None): client = Client.query(Client.client_key == client_key).get() if client: nonce = Nonce( nonce=nonce, timestamp=timestamp, client=client.key) if request_token: req_token = RequestToken.query( RequestToken.token == request_token).get() nonce.request_token = req_token.key if access_token: token = AccessToken.query( AccessToken.token == access_token).get() nonce.access_token = token.key nonce.put()
def save_timestamp_and_nonce(self, client_key, timestamp, nonce, request_token=None, access_token=None): client = Client.query(Client.client_key == client_key).get() if client: nonce = Nonce(nonce=nonce, timestamp=timestamp, client=client.key) if request_token: req_token = RequestToken.query( RequestToken.token == request_token).get() nonce.request_token = req_token.key if access_token: token = AccessToken.query( AccessToken.token == access_token).get() nonce.access_token = token.key nonce.put()
def save_timestamp_and_nonce(self, client_key, timestamp, nonce, request_token=None, access_token=None): client = Client.find_one({'client_key': client_key}) if client: nonce = Nonce(nonce, timestamp) nonce.client_id = client['_id'] if request_token: req_token = RequestToken.find_one({'token': request_token}) nonce.request_token_id = req_token['_id'] if access_token: token = AccessToken.find_one({'token': access_token}) nonce.access_token_id = token['_id'] nonce.insert()
def save_access_token(self, client_key, access_token, request_token, realm=None, secret=None): client = Client.find_one({'client_key':client_key}) if client: req_token = RequestToken.find_one( {'token':request_token}, as_obj = True) if req_token: if not req_token['user_id']: req_token['user_id'] = current_user.get_id() req_token.save() token = AccessToken.find_or_create( client_id = client['_id'], user_id = req_token['user_id'],#current_user.get_id(), realm = realm if realm else req_token['realm']) token.secret = secret token.token = access_token token.save()
def setUp(self): self.user = User(username='******', password='******') self.client = Client(user=self.user, redirect_uris=[REDIRECT_URI], realms=['read'], client_key=CONSUMER_KEY, client_secret=CONSUMER_SECRET) self.request_token = RequestToken(client=self.client, token=REQUEST_TOKEN, secret=REQUEST_TOKEN_SECRET, redirect_uri=REDIRECT_URI, realms=['read'], user=self.user) self.access_token = AccessToken(client=self.client, user=self.user, realms=[REDIRECT_URI], token=ACCESS_TOKEN, secret=ACCESS_TOKEN_SECRET) self.nonce = Nonce(client_key=self.client.client_key, timestamp=TIMESTAMP, nonce=NONCE, request_token=REQUEST_TOKEN, access_token=ACCESS_TOKEN)
def authorize(self): if request.method == u"POST" or 'done' in request.args: token = request.form.get("oauth_token") if not token: token = request.args.get("oauth_token") return self.authorized(token, request=request) else: # TODO: Authenticate client token_key = request.args.get(u"oauth_token") token = RequestToken.find_one({'token': token_key}) if token: realm = token.get('realm') # TODO: Make this more robust. session['realm'] = realm if realm and realm in APIS: #url = ("%s?first_oauth_token=%s" % # (url_for('%s.finished' % realm, _external = True), token_key)) session['original_token'] = token_key url = url_for('%s.finished' % realm, _external=True) resp = APIS[realm].authorize(callback=url, **APIS[realm].auth_params) return resp return render_template(u"authorize.html", token=token_key, realm=token['realm'].title()) # If we got here, it's because we don't recognize the client attempting # to connect. Send them an "unauthorized" error. abort(403)
def get_callback(self, request_token): return RequestToken.find_one({'token': request_token})['callback']
def get(self): auth = tweepy.OAuthHandler(Const.CONSUMER_KEY, Const.CONSUMER_SECRET) auth_url = auth.get_authorization_url() request_token = RequestToken(token_key=auth.request_token.key, token_secret=auth.request_token.secret) request_token.put() self.redirect(auth_url)
def save_verifier(self, request_token, verifier): token = RequestToken.query(RequestToken.token == request_token).get() token.verifier = verifier token.resource_owner = g.user.key token.put()
def save_verifier(self, request_token, verifier): token = RequestToken.find_one({'token':request_token}) token['verifier'] = verifier token['resource_owner_id'] = g.user['_id'] RequestToken.get_collection().save(token)
def save_verifier(self, request_token, verifier): token = RequestToken.find_one({'token':request_token}) token['verifier'] = verifier token['user_id'] = current_user.get_id() RequestToken.get_collection().save(token)
def save_verifier(self, request_token, verifier): token = RequestToken.query( RequestToken.token == request_token).get() token.verifier = verifier token.resource_owner = g.user.key token.put()
def save_verifier(self, request_token, verifier): token = RequestToken.find_one({'token': request_token}) token['verifier'] = verifier token['user_id'] = current_user.get_id() RequestToken.get_collection().save(token)
def save_verifier(self, request_token, verifier): token = RequestToken.find_one({'token': request_token}) token['verifier'] = verifier token['resource_owner_id'] = g.user['_id'] RequestToken.get_collection().save(token)
def get_callback(self, request_token): return RequestToken.find_one( {'token':request_token})['callback']