activitypub/apps/blog/app.py

### This file and folder are based on:
### https://github.com/tsileo/microblog.pub
### https://github.com/tsileo/little-boxes

### Work In Progress! When complete, this
### file should only contain the specific
### logic for a micro blog.

from html2text import html2text
from urllib.parse import urlparse
import bleach
import logging

logging.getLogger().setLevel(logging.DEBUG)

from activitypub import VERSION
from activitypub.manager.base import app
from activitypub.bson import ObjectId

## Pick one:
from activitypub.manager import FlaskManager as Manager
#from activitypub.manager import TornadoManager as Manager
#from activitypub.manager import Manager as Manager

from activitypub.database import *
## Pick one:
database = RedisDatabase("redis://localhost:6379/0")
#database = MongoDatabase("mongodb://localhost:27017", "dsblank_localhost:5000")
#database = ListDatabase()
#database = SQLDatabase("sqlite://")
#database = SQLDatabase("sqlite:///sqlite.db")

manager = Manager(database=database)
manager.setup_css()
## FIXME: get rid of all of these:
manager.config.update({
    "ME": {
        "url": "https://example.com",
        "icon": {"url": "https://example.com"},
        "icon_url": 'https://cs.brynmawr.edu/~dblank/images/doug-sm-orig.jpg',
        "summary": "I'm just me."},
    "NAME": "ActivityPub Blog",
    "ID": "http://localhost:%s/dsblank" % manager.port,
    "BASE_URL": "http://localhost:%s" % manager.port,
    })

"""
### Some fake data:

database.activities.clear()
database.actors.clear()

for id in ["dsblank", "alyssa", "jones", "smith"]:
    person = manager.Person(**{"id": id,
                               "temp_id": id,
                               'name': "$temp_id",
                               'preferredUsername': "$temp_id",
    })
    if not database.actors.find_one({"id": person.id}):
        database.actors.insert_one(person.to_dict())

for i in range(10):
    person = manager.Person(id="dsblank")
    text = "This is note #%s" % i
    note = manager.Note(
        **{
            'sensitive': False,
            'attributedTo': '$DOMAIN',
            'cc': ['$DOMAIN/followers'],
            'to': ['https://www.w3.org/ns/activitystreams#Public'],
            'content': '<p>$source.content</p>',
            'tag': [],
            'source': {'mediaType': 'text/markdown', 'content': text},
            'published': '$NOW',
            'temp_uuid': "$UUID",
            'id': '$DOMAIN/outbox/$temp_uuid/activity',
            'url': '$DOMAIN/note/$temp_uuid',
        })
    create = manager.Create(
        **{
            'context': ['https://www.w3.org/ns/activitystreams',
                         'https://w3id.org/security/v1',
                         {'Hashtag': 'as:Hashtag',
                          'sensitive': 'as:sensitive',
                          'toot': 'http://joinmastodon.org/ns#',
                          'featured': 'toot:featured'}],
            'actor': '$DOMAIN',
            'object': note.to_dict(),
            'published': '$NOW',
            'to': ['https://www.w3.org/ns/activitystreams#Public'],
            'cc': ['$DOMAIN/followers'],
            'id': '$DOMAIN/outbox/%s' % note.temp_uuid,
        }
    )
    message = manager.Create(
        **{
            'activity': create.to_dict(),
            'box': 'outbox',
            'type': ['Create'],
            'remote_id': '$DOMAIN/outbox/%s' % note.temp_uuid,
            'meta': {'undo': False, 'deleted': False},
            })

    database.activities.insert_one(message.to_dict())
"""

#### The routes:

@app.route("/notes", endpoint="notes")
@app.route("/")
def route_index(self, *args, **kwargs):
    logging.info("args: %s,  kwargs: %s" % (args, kwargs))
    q = {
        "box": "outbox",
        "type": {"$in": ["Create", "Announce"]},
        "activity.object.inReplyTo": None,
        "meta.deleted": False,
        "meta.undo": False,
    }
    outbox_data, older_than, newer_than = paginated_query(self, self.database.activities, q)
    logging.info("outbox_data: %s" % outbox_data)
    return self.render_template(
        "index.html",
        outbox_data=outbox_data,
        older_than=older_than,
        newer_than=newer_than,
    )

@app.route("/admin", methods=["GET"])
#@login_required
def route_admin(self):
    q = {
        "meta.deleted": False,
        "meta.undo": False,
        "type": "like",
        "box": "outbox",
    }
    col_liked = self.database.activities.count(q)

    return self.render_template(
        "admin.html",
        instances=list(self.database.instances.find()),
        inbox_size=self.database.activities.count({"box": "inbox"}),
        outbox_size=self.database.activities.count({"box": "outbox"}),
        col_liked=col_liked,
        col_followers=self.database.activities.count(
            {
                "box": "inbox",
                "type": "follow",
                "meta.undo": False,
            }
        ),
        col_following=self.database.activities.count(
            {
                "box": "outbox",
                "type": "follow",
                "meta.undo": False,
            }
        ),
    )

@app.route("/login", methods=["POST", "GET"])
def route_login(self):
    return self.redirect(
        self.get_argument("redirect", None) or self.url_for("admin_notifications")
    )

@app.route("/admin/notifications")
def admin_notifications(self):
    # FIXME(tsileo): show unfollow (performed by the current actor) and liked???
    mentions_query = {
        "type": "Create",
        "activity.object.tag.type": "Mention",
        "activity.object.tag.name": "@dsblank@https://example.com",
        "meta.deleted": False,
    }
    replies_query = {
        "type": "Create",
        "activity.object.inReplyTo": {"$regex": "^https://example.com"},
    }
    announced_query = {
        "type": "Announce",
        "activity.object": {"$regex": "^https://example.com"},
    }
    new_followers_query = {"type": "Follow"}
    unfollow_query = {
        "type": "Undo",
        "activity.object.type": "Follow",
    }
    followed_query = {"type": "Accept"}
    q = {
        "box": "inbox",
        "$or": [
            mentions_query,
            announced_query,
            replies_query,
            new_followers_query,
            followed_query,
            unfollow_query,
        ],
    }
    inbox_data, older_than, newer_than = paginated_query(self, self.database.activities, q)

    return self.render_template(
        "stream.html",
        inbox_data=inbox_data,
        older_than=older_than,
        newer_than=newer_than,
    )

### FIXME: move paging to Manager
def paginated_query(self, db, q, limit=5, sort_key="_id"):
    older_than = newer_than = None
    query_sort = -1
    first_page = (not self.get_argument("older_than", None) and
                  not self.get_argument("newer_than", None))

    query_older_than = self.get_argument("older_than", None)
    query_newer_than = self.get_argument("newer_than", None)

    if query_older_than:
        q["_id"] = {"$lt": ObjectId(query_older_than)}
    elif query_newer_than:
        q["_id"] = {"$gt": ObjectId(query_newer_than)}
        query_sort = 1

    outbox_data = list(db.find(q, limit=limit + 1).sort(sort_key, query_sort))
    outbox_len = len(outbox_data)
    outbox_data = sorted(
        outbox_data[:limit], key=lambda x: str(x[sort_key]), reverse=True
    )
    if query_older_than:
        newer_than = str(outbox_data[0]["_id"])
        if outbox_len == limit + 1:
            older_than = str(outbox_data[-1]["_id"])
    elif query_newer_than:
        older_than = str(outbox_data[-1]["_id"])
        if outbox_len == limit + 1:
            newer_than = str(outbox_data[0]["_id"])
    elif first_page and outbox_len == limit + 1:
        older_than = str(outbox_data[-1]["_id"])
    return outbox_data, older_than, newer_than


@app.context_processor
def context_processor(self):
    q = {
        "type": "Create",
        "activity.object.type": "Note",
        "activity.object.inReplyTo": None,
        "meta.deleted": False,
    }
    notes_count = self.database.activities.find(
        {"box": "outbox", "$or": [q, {"type": "Announce", "meta.undo": False}]}
    ).count()
    q = {"type": "Create", "activity.object.type": "Note", "meta.deleted": False}
    with_replies_count = self.database.activities.find(
        {"box": "outbox", "$or": [q, {"type": "Announce", "meta.undo": False}]}
    ).count()
    liked_count = self.database.activities.count(
        {
            "box": "outbox",
            "meta.deleted": False,
            "meta.undo": False,
            "type": "Like",
        }
    )
    followers_q = {
        "box": "inbox",
        "type": "follow",
        "meta.undo": False,
    }
    following_q = {
        "box": "outbox",
        "type": "follow",
        "meta.undo": False,
    }
    return {
        "microblogpub_version": VERSION,
        "followers_count": self.database.activities.count(followers_q),
        "following_count": self.database.activities.count(following_q),
        "notes_count": notes_count,
        "liked_count": liked_count,
        "with_replies_count": with_replies_count,
        "DOMAIN": "localhost:%s/test" % (self.port,), # TODO: update on each fetch, include full URL, /test
    }

@app.route("/test")
def route_test(self):
    return self.render_template("test.html")

### The filters:

@app.filter
def html2plaintext(self, body, *args, **kwargs):
    return html2text(body)

def _to_list(item):
    if not isinstance(item, list):
        return list(item)
    return item

@app.filter
def has_type(self, doc, _type):
    if _type in _to_list(doc["type"]):
        return True
    return False

@app.filter
def get_actor(self, url):
    retval = self.database.actors.find_one({"id": self.config["ID"]})
    if retval is not None:
        return retval

@app.filter
def get_url(self, u):
    if isinstance(u, dict):
        return u["href"]
    elif isinstance(u, str):
        return u
    else:
        return u

@app.filter
def get_actor_icon_url(self, url, size):
    return _get_file_url(url, size, Kind.ACTOR_ICON)

@app.filter
def domain(self, url):
    return urlparse(url).netloc

@app.filter
def permalink_id(self, val):
    return str(hash(val))

@app.filter
def is_from_outbox(self, t):
    logging.warning("is_from_outbox(%s)" % (t,))
    return True
    return t.startswith(ID)

@app.filter
def format_timeago(self, val):
    return "OK"
    if val:
        dt = parser.parse(val)
        return timeago.format(dt, datetime.now(timezone.utc))
    return val

# HTML/templates helper
ALLOWED_TAGS = [
    "a",
    "abbr",
    "acronym",
    "b",
    "br",
    "blockquote",
    "code",
    "pre",
    "em",
    "i",
    "li",
    "ol",
    "strong",
    "ul",
    "span",
    "div",
    "p",
    "h1",
    "h2",
    "h3",
    "h4",
    "h5",
    "h6",
]

def clean_html(html):
    return bleach.clean(html, tags=ALLOWED_TAGS)

@app.filter
def clean(self, html):
    return clean_html(html)

@app.filter
def not_only_imgs(self, attachment):
    for a in attachment:
        if not _is_img(a["url"]):
            return True
    return False

@app.filter
def is_img(self, filename):
    return _is_img(filename)

@app.filter
def get_attachment_url(self, url, size):
    return _get_file_url(url, size, Kind.ATTACHMENT)

@app.filter
def format_time(self, val):
    return "OK"
    if val:
        dt = parser.parse(val)
        return datetime.strftime(dt, "%B %d, %Y, %H:%M %p")
    return val

@app.filter
def quote_plus(self, t):
    import urllib
    return urllib.parse.quote_plus(t)

if __name__ == "__main__":
    manager.run()