Added: RedisDatabase, FlaskManager

activitypub/database/__init__.py

@@ -2,3 +2,4 @@
 from .base import Database, Table
 from .dummy import DummyDatabase
 from .mongodb import MongoDatabase
+from .redisdb import RedisDatabase

activitypub/database/dummy.py

@@ -157,7 +157,7 @@ class DummyTable(Table):
         return repr(self.data)
 
     def drop(self):
-        self.data = []
+        self.data.clear()
 
     def sort(self, sort_key, sort_order):
         # sort_key = "_id"

activitypub/manager/base.py

@@ -15,6 +15,7 @@ class Manager():
     """
     app_name = "activitypub"
     version = "1.0.0"
+    key_path = "./keys"
     def __init__(self, context=None, defaults=None, database=None):
         from ..classes import ActivityPubBase
         self.callback = lambda box, activity_id: None
@@ -196,45 +197,43 @@ class Manager():
         response.raise_for_status()
         return response.json()
 
-    def get_secret_key(self, name):
-        filename = "%s.key" % name
-        if not os.path.exists():
+    def load_secret_key(self, name):
+        key = self._load_secret_key(name)
+        ## Override to do something with secret key
+
+    def _load_secret_key(self, name):
+        """
+        Load or create a secret key for name.
+        """
+        filename = os.path.join(self.key_path, "%s.key" % name)
+        if not os.path.exists(filename):
+            os.makedirs(os.path.dirname(filename), exist_ok=True)
             key = binascii.hexlify(os.urandom(32)).decode("utf-8")
             with open(filename, "w+") as f:
                 f.write(key)
-            return key
         else:
-            with open(key_path) as f:
-                return f.read()
+            with open(filename) as f:
+                key = f.read()
+        return key
 
-    def get_rsa_key(self, owner, user, domain):
-        """"
-        Loads or generates an RSA key.
-        """
-        k = Key(owner)
-        user = user.replace(".", "_")
-        domain = domain.replace(".", "_")
-        key_path = os.path.join(KEY_DIR, f"key_{user}_{domain}.pem")
-        if os.path.isfile(key_path):
-            with open(key_path) as f:
-                privkey_pem = f.read()
-                k.load(privkey_pem)
-        else:
-            k.new()
-            with open(key_path, "w") as f:
-                f.write(k.privkey_pem)
-        return k
-
-    def after_request(self, f):
+    def after_request(self, function):
         """
         Decorator
         """
-        return f
+        return function
+
+    def login_required(self, function):
+        """
+        Decorator
+        """
+        ## decorate function here
+        return function
 
     def template_filter(self):
         """
         Decorator
         """
-        def decorator(f):
-            return f
+        def decorator(function):
+            return function
         return decorator
+

activitypub/manager/flaskman.py

@@ -1,17 +1,28 @@
-from flask import (Flask, Response)
+from flask import (Flask, Response, abort,
+                   jsonify as flask_jsonify,
+                   redirect, render_template,
+                   request, session, url_for)
+
+from flask_wtf.csrf import CSRFProtect
 
 from .base import Manager
-    
+
 class FlaskManager(Manager):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.app = Flask(__name__)
+        self.app.config.update(WTF_CSRF_CHECK_DEFAULT=False)
+        self.csrf = CSRFProtect(app)
+
+    def load_secret_key(self, name):
+        key = self._load_secret_key(name)
+        self.app.secret_key = key
 
     def after_request(self, f):
         """
         Decorator
         """
-        self.app.after_request(f)
+        return self.app.after_request(f)
 
     def template_filter(self):
         """
@@ -20,3 +31,11 @@ class FlaskManager(Manager):
         def decorator(f):
             self.app.template_filter()(f)
         return decorator
+
+    def login_required(self, f):
+        @wraps(f)
+        def decorated_function(*args, **kwargs):
+            if not session.get("logged_in"):
+                return redirect(url_for("login", next=request.url))
+            return f(*args, **kwargs)
+        return decorated_function