First AP routes returning JSON in Torndao and FLask

activitypub/classes.py

@@ -58,7 +58,7 @@ class ActivityPubBase():
         """
         from functools import reduce
         # Find all items that don't depend on anything:
-        extra_items_in_deps = reduce(set.union, data.values()) - set(data.keys())
+        extra_items_in_deps = reduce(set.union, data.values(), set()) - set(data.keys())
         # Add empty dependences where needed:
         data.update({item: set() for item in extra_items_in_deps})
         while True:
@@ -167,12 +167,6 @@ class Actor(Object):
     ap_endpoints = {}
     ap_sharedInbox = None
 
-    def on_post(self, activity):
-        if activity.type != "Create":
-            obj = activity.object
-        else:
-            obj = activity
-
 class Application(Actor):
     ap_type = "Application"
 
@@ -224,6 +218,11 @@ class Note(Document):
     """
     ap_type = "Note"
 
+class Activity(Document):
+    """
+    """
+    ap_type = "Activity"
+
 class Create(Object):
     """
     """
@@ -231,6 +230,7 @@ class Create(Object):
 
 ActivityPubBase.CLASSES = {
     "Actor": Actor,
+    "Activity": Activity,
     "Application": Application,
     "Group": Group,
     "Organization": Organization,

activitypub/manager/ap_routes.py

@@ -2,32 +2,44 @@ from .base import app
 
 @app.route("/user/<nickname>", ["GET"])
 def route_user(self, nickname):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-    )
+    #obj = self.database.actors.find(id=nickname)
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/user/<nickname>/publickey", ["GET"])
 def route_publickey(self, nickname):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/user/<nickname>/outbox", ["GET"])
 def route_user_outbox(self, nickname):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/user/<nickname>/outbox/<page>", ["GET"])
 def route_outbox_page(self, nickname, page):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-        page=page,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 #@app.route("/user/<nickname>/outbox", ["POST"])
 #def route_(self):
@@ -35,18 +47,23 @@ def route_outbox_page(self, nickname, page):
 
 @app.route("/user/<nickname>/inbox", ["GET"])
 def route_inbox(self, nickname):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/user/<nickname>/inbox/<page>", ["GET"])
 def route_inbox_page(self, nickname, page):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-        page=page,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 #@app.route("/user/<nickname>/inbox", ["POST"])
 #def route_(self):
@@ -54,100 +71,133 @@ def route_inbox_page(self, nickname, page):
 
 @app.route("/user/<nickname>/followers", ["GET"])
 def route_followers(self, nickname):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/user/<nickname>/followers/<page>", ["GET"])
 def route_followers_page(self, nickname, page):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-        page=page,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/user/<nickname>/following", ["GET"])
 def route_following(self, nickname):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/user/<nickname>/following/<page>", ["GET"])
 def route_following_page(self, nickname, page):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-        page=page,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/user/<nickname>/liked", ["GET"])
 def route_liked(self, nickname):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/user/<nickname>/liked/<page>", ["GET"])
 def route_liked_page(self, nickname, page):
-    return self.render_template(
-        "test.html",
-        nickname=nickname,
-        page=page,
-    )
+    obj = self.Actor(id=nickname)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/activity/<uuid>", ["GET"])
 def route_activity(self, uuid):
-    return self.render_template(
-        "test.html",
-        uuid=uuid,
-    )
+    obj = self.manager.Note(id=uuid)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/activity/<uuid>/replies", ["GET"])
 def route_activity_replies(self, uuid):
-    return self.render_template(
-        "test.html",
-        uuid=uuid,
-    )
+    obj = self.Activity(id=uuid)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/activity/<uuid>/replies/<page>", ["GET"])
 def route_activity_replies_page(self, uuid, page):
-    return self.render_template(
-        "test.html",
-        uuid=uuid,
-        page=page,
-    )
+    obj = self.Activity(id=uuid)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/activity/<uuid>/likes", ["GET"])
 def route_activity_likes(self, uuid):
-    return self.render_template(
-        "test.html",
-        uuid=uuid,
-    )
+    obj = self.Activity(id=uuid)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/activity/<uuid>/likes/<page>", ["GET"])
 def route_activity_likes_page(self, uuid, page):
-    return self.render_template(
-        "test.html",
-        uuid=uuid,
-        page=page,
-    )
+    obj = self.Activity(id=uuid)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/activity/<uuid>/shares", ["GET"])
 def route_activity_shares(self, uuid):
-    return self.render_template(
-        "test.html",
-        uuid=uuid,
-    )
+    obj = self.Activity(id=uuid)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/activity/<uuid>/shares/<page>", ["GET"])
 def route_activity_shares_page(self, uuid, page):
-    return self.render_template(
-        "test.html",
-        uuid=uuid,
-        page=page,
-    )
+    obj = self.Activity(id=uuid)
+    if obj:
+        return self.render_json(
+            obj.to_dict()
+        )
+    else:
+        self.error(404)
 
 @app.route("/content/<uuid>", ["GET"])
 def route_content(self, uuid):

activitypub/manager/base.py

@@ -121,12 +121,18 @@ class Manager():
     def render_template(self, template_name, **kwargs):
         pass
 
+    def render_json(self, json_object):
+        pass
+
     def redirect(self, url):
         pass
 
     def url_for(self, name):
         pass
 
+    def error(self, error_number):
+        self.render_template("%s.html" % error_number)
+
     @property
     def request(self):
         return None

activitypub/manager/flaskman.py

@@ -4,6 +4,7 @@ try:
                        redirect, render_template,
                        request, session, url_for)
     from flask_wtf.csrf import CSRFProtect
+    from flask import jsonify
 except:
     pass # flask not available
 
@@ -13,6 +14,9 @@ from .._version import VERSION
 class FlaskManager(Manager):
     """
     """
+    def render_json(self, obj):
+        return jsonify(obj) # has correct header type set
+
     def render_template(self, template_name, **kwargs):
         ## TODO : add context_processor
         q = {

activitypub/manager/tornadoman.py

@@ -17,13 +17,22 @@ def make_handler(f, manager, methods):
     """
     ## TODO: handle GET, POST methods
     class Handler(RequestHandler):
-
         def get(self, *args, **kwargs):
+            self.database = manager.database
+            self.Actor = manager.Actor
+            self.Activity = manager.Activity
+            self.Note = manager.Note
             return f(self, *args, **kwargs)
 
         def render_template(self, name, **kwargs):
             self.write(manager.render_template(name, **kwargs))
 
+        def render_json(self, obj):
+            self.write(obj) # will set header to JSON mimetype
+
+        def error(self, error_number):
+            self.write(manager.render_template("%s.html" % error_number))
+
     return Handler
 
 class TornadoManager(Manager):