Admin interface for snippets

flask_website/openid_auth.py

@@ -1,23 +1,14 @@
 from time import time
-from hashlib import sha1
 
 from openid.association import Association
 from openid.store.interface import OpenIDStore
-from openid.consumer.consumer import Consumer, SUCCESS, CANCEL
-from openid.consumer import discover
 from openid.store import nonce
 
-# python-openid is a really stupid library in that regard, we have
-# to disable logging by monkey patching
-from openid import oidutil
-oidutil.log = lambda *a, **kw: None
-
-from flask import request, redirect, abort, url_for, flash, session
 from flask_website.database import User, db_session, OpenIDAssociation, \
      OpenIDUserNonce
 
 
-class WebsiteOpenIDStore(OpenIDStore):
+class DatabaseOpenIDStore(OpenIDStore):
     """Implements the open store for the website using the database."""
 
     def storeAssociation(self, server_url, association):
@@ -30,6 +21,7 @@ class WebsiteOpenIDStore(OpenIDStore):
             assoc_type=association.assoc_type
         )
         db_session.add(assoc)
+        db_session.commit()
 
     def getAssociation(self, server_url, handle=None):
         q = OpenIDAssociation.query.filter_by(server_url=server_url)
@@ -46,10 +38,13 @@ class WebsiteOpenIDStore(OpenIDStore):
         return result_assoc
 
     def removeAssociation(self, server_url, handle):
-        return OpenIDAssociation.query.filter(
-            (OpenIDAssociation.server_url == server_url) &
-            (OpenIDAssociation.handle == handle)
-        ).delete()
+        try:
+            return OpenIDAssociation.query.filter(
+                (OpenIDAssociation.server_url == server_url) &
+                (OpenIDAssociation.handle == handle)
+            ).delete()
+        finally:
+            db_session.commit()
 
     def useNonce(self, server_url, timestamp, salt):
         if abs(timestamp - time()) > nonce.SKEW:
@@ -64,64 +59,21 @@ class WebsiteOpenIDStore(OpenIDStore):
         rv = OpenIDUserNonce(server_url=server_url, timestamp=timestamp,
                              salt=salt)
         db_session.add(rv)
+        db_session.commit()
         return True
 
     def cleanupNonces(self):
-        return OpenIDUserNonce.query.filter(
-            OpenIDUserNonce.timestamp <= int(time() - nonce.SKEW)
-        ).delete()
+        try:
+            return OpenIDUserNonce.query.filter(
+                OpenIDUserNonce.timestamp <= int(time() - nonce.SKEW)
+            ).delete()
+        finally:
+            db_session.commit()
 
     def cleanupAssociations(self):
-        return OpenIDAssociation.query.filter(
-            OpenIDAssociation.lifetime < int(time())
-        ).delete()
-
-
-def redirect_back():
-    return redirect(request.values.get('next') or url_for('general.index'))
-
-
-def check_return_from_provider():
-    if request.args.get('openid_complete') != u'yes':
-        return
-    try:
-        consumer = Consumer(session, WebsiteOpenIDStore())
-        openid_response = consumer.complete(request.args.to_dict(),
-                                            url_for('general.login',
-                                                    _external=True))
-        if openid_response.status == SUCCESS:
-            return create_or_login(openid_response.identity_url)
-        elif openid_response.status == CANCEL:
-            flash(u'Error: The request was cancelled')
-            return redirect(url_for('general.login'))
-        flash(u'Error: OpenID authentication error')
-        return redirect(url_for('general.login'))
-    finally:
-        db_session.commit()
-
-
-def create_or_login(identity_url):
-    session['openid'] = identity_url
-    user = User.query.filter_by(openid=identity_url).first()
-    if user is None:
-        next_url = request.values.get('next')
-        return redirect(url_for('general.first_login', next=next_url))
-    flash(u'Successfully logged in')
-    return redirect_back()
-
-
-def login(identity_url):
-    try:
         try:
-            consumer = Consumer(session, WebsiteOpenIDStore())
-            auth_request = consumer.begin(identity_url)
-        except discover.DiscoveryFailure:
-            flash(u'Error: The OpenID was invalid')
-            return redirect(url_for('general.login'))
-        trust_root = request.host_url
-        next_url = request.values.get('next') or url_for('general.index')
-        redirect_to = url_for('general.login', openid_complete='yes',
-                              next=next_url, _external=True)
-        return redirect(auth_request.redirectURL(trust_root, redirect_to))
-    finally:
-        db_session.commit()
+            return OpenIDAssociation.query.filter(
+                OpenIDAssociation.lifetime < int(time())
+            ).delete()
+        finally:
+            db_session.commit()