6 | {% include "header.html" %}
7 |
19 | {% endblock %}
20 |
--------------------------------------------------------------------------------
/templates/remote_follow.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block header %}
4 | {% endblock %}
5 | {% block content %}
6 |
8 |
9 |
17 |
18 |
10 | {% for item in inbox_data %}
11 |
16 | {{ item |remove_mongo_id|tojson(indent=4) }}
7 | {% include "header.html" %}
8 |
9 |
17 |
18 | {% endblock %}
19 |
--------------------------------------------------------------------------------
/core/jsonld.py:
--------------------------------------------------------------------------------
1 | MICROBLOGPUB = {
2 | "@context": [
3 | "https://www.w3.org/ns/activitystreams",
4 | "https://w3id.org/security/v1",
5 | {
6 | "Hashtag": "as:Hashtag",
7 | "PropertyValue": "schema:PropertyValue",
8 | "manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
9 | "ostatus": "http://ostatus.org#",
10 | "schema": "http://schema.org",
11 | "sensitive": "as:sensitive",
12 | "toot": "http://joinmastodon.org/ns#",
13 | "totalItems": "as:totalItems",
14 | "value": "schema:value",
15 | "Emoji": "toot:Emoji",
16 | },
17 | ]
18 | }
19 |
--------------------------------------------------------------------------------
/templates/direct_messages.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}DMs - {{ config.NAME }}{% endblock %}
4 | {% block header %}
5 |
6 | {% endblock %}
7 | {% block content %}
8 |
9 |
20 | {% endblock %}
21 |
--------------------------------------------------------------------------------
/templates/error.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}{{code}} {{status_text}} - {{ config.NAME }}{% endblock %}
4 | {% block header %}
5 | {% endblock %}
6 | {% block content %}
7 |
10 |
11 | {% for thread in threads %}
12 |
19 | With {{ ", ".join(thread.participants) }} 13 | {{ thread.len }} message{% if thread.len > 1 %}s{% endif %} 14 |
15 | {{ utils.display_note(thread.last_reply.activity.object, meta=thread.last_reply.meta) }} 16 | {% endfor %} 17 | 18 |
8 | {% if not request.path.startswith('/admin') %}
9 | {% include "header.html" %}
10 | {% endif %}
11 |
12 |
23 |
24 | {% endblock %}
25 |
--------------------------------------------------------------------------------
/templates/about.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block header %}
4 | {% endblock %}
5 | {% block content %}
6 | {{code}} {{status_text}}
13 |Something went wrong :(
14 | {% if tb %} 15 |
16 |
21 | {% endif %}
22 | Please consider opening an issue on GitHub.
Here is the traceback:
18 | {{ tb }}
19 |
7 |
8 | {% include "header.html" %}
9 |
10 |
22 | {% endblock %}
23 |
--------------------------------------------------------------------------------
/templates/admin.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}Admin - {{ config.NAME }}{% endblock %}
4 | {% block content %}
5 |
11 |
20 |
21 |
12 | 
13 |
14 |
15 |
16 | {{ text | safe }}
17 |
19 | {{ me.summary }}
18 |
6 | {% include "header.html" %}
7 |
28 | {% endblock %}
29 |
--------------------------------------------------------------------------------
/utils/__init__.py:
--------------------------------------------------------------------------------
1 | import logging
2 | from datetime import datetime
3 | from datetime import timezone
4 |
5 | from dateutil import parser
6 | from little_boxes import activitypub as ap
7 |
8 | logger = logging.getLogger(__name__)
9 |
10 |
11 | def strtobool(s: str) -> bool:
12 | if s in ["y", "yes", "true", "on", "1"]:
13 | return True
14 | if s in ["n", "no", "false", "off", "0"]:
15 | return False
16 |
17 | raise ValueError(f"cannot convert {s} to bool")
18 |
19 |
20 | def parse_datetime(s: str) -> datetime:
21 | # Parses the datetime with dateutil
22 | dt = parser.parse(s)
23 |
24 | # If no TZ is set, assumes it's UTC
25 | if not dt.tzinfo:
26 | dt = dt.replace(tzinfo=timezone.utc)
27 |
28 | return dt
29 |
30 |
31 | def now() -> str:
32 | return ap.format_datetime(datetime.now(timezone.utc))
33 |
--------------------------------------------------------------------------------
/templates/u2f.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block header %}
4 | {% endblock %}
5 | {% block content %}
6 |
8 |
26 |
27 | Admin
9 |Links
10 |-
11 |
- IndieAuth logs 12 |
- Poussetaches tasks 13 |
DB
15 |-
16 |
- Inbox size: {{ inbox_size }} 17 |
- Outbox size: {{ outbox_size }} 18 |
Collections
20 |-
21 |
- followers: {{ col_followers }} 22 |
- following: {{ col_following }} 23 |
- liked: {{col_liked }} 24 |
7 | {% if session.logged_in %}logged{% else%}not logged{%endif%}
8 |
9 |
13 |
14 |
15 |
29 | {% endblock %}
30 |
--------------------------------------------------------------------------------
/tests/integration_test.py:
--------------------------------------------------------------------------------
1 | import os
2 |
3 | import pytest
4 | import requests
5 | from html2text import html2text
6 |
7 |
8 | @pytest.fixture
9 | def config():
10 | """Return the current config as a dict."""
11 | import yaml
12 |
13 | with open(
14 | os.path.join(os.path.dirname(__file__), "..", "config/me.yml"), "rb"
15 | ) as f:
16 | yield yaml.load(f)
17 |
18 |
19 | def resp2plaintext(resp):
20 | """Convert the body of a requests reponse to plain text in order to make basic assertions."""
21 | return html2text(resp.text)
22 |
23 |
24 | def test_ping_homepage(config):
25 | """Ensure the homepage is accessible."""
26 | resp = requests.get("http://localhost:5005")
27 | resp.raise_for_status()
28 | assert resp.status_code == 200
29 | body = resp2plaintext(resp)
30 | assert config["name"] in body
31 | assert f"@{config['username']}@{config['domain']}" in body
32 |
--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: '2'
2 | services:
3 | web:
4 | image: 'microblogpub:latest'
5 | ports:
6 | - "127.0.0.1:${WEB_PORT}:5005"
7 | volumes:
8 | - "${CONFIG_DIR}:/app/config"
9 | - "./static:/app/static"
10 | environment:
11 | - MICROBLOGPUB_MONGODB_HOST=mongo:27017
12 | - MICROBLOGPUB_INTERNAL_HOST=http://${COMPOSE_PROJECT_NAME}_web_1:5005
13 | - MICROBLOGPUB_POUSSETACHES_HOST=http://${COMPOSE_PROJECT_NAME}_poussetaches_1:7991
14 | - POUSSETACHES_AUTH_KEY=${POUSSETACHES_AUTH_KEY}
15 | - COMPOSE_PROJECT_NAME=${COMPOSE_PROJECT_NAME}
16 | mongo:
17 | image: "mongo:3"
18 | volumes:
19 | - "${DATA_DIR}/mongodb:/data/db"
20 | poussetaches:
21 | image: "poussetaches/poussetaches:latest"
22 | volumes:
23 | - "${DATA_DIR}/poussetaches:/app/poussetaches_data"
24 | environment:
25 | - POUSSETACHES_AUTH_KEY=${POUSSETACHES_AUTH_KEY}
26 | # ports:
27 | # - "127.0.0.1:${POUSSETACHES_PORT}:7991"
28 |
--------------------------------------------------------------------------------
/utils/highlight.py:
--------------------------------------------------------------------------------
1 | from functools import lru_cache
2 |
3 | from bs4 import BeautifulSoup
4 | from pygments import highlight as phighlight
5 | from pygments.formatters import HtmlFormatter
6 | from pygments.lexers import guess_lexer
7 |
8 | from config import THEME_STYLE
9 | from config import ThemeStyle
10 |
11 | _FORMATTER = HtmlFormatter(
12 | style="default" if THEME_STYLE == ThemeStyle.LIGHT else "vim"
13 | )
14 |
15 | HIGHLIGHT_CSS = _FORMATTER.get_style_defs()
16 |
17 |
18 | @lru_cache(512)
19 | def highlight(html: str) -> str:
20 | soup = BeautifulSoup(html, "html5lib")
21 | for code in soup.find_all("code"):
22 | if not code.parent.name == "pre":
23 | continue
24 | lexer = guess_lexer(code.text)
25 | tag = BeautifulSoup(
26 | phighlight(code.text, lexer, _FORMATTER), "html5lib"
27 | ).body.next
28 | pre = code.parent
29 | pre.replaceWith(tag)
30 | out = soup.body
31 | out.name = "div"
32 | return str(out)
33 |
--------------------------------------------------------------------------------
/core/remote.py:
--------------------------------------------------------------------------------
1 | from urllib.parse import urlparse
2 |
3 | from core.db import _Q
4 | from core.db import update_one_remote
5 | from utils import now
6 |
7 |
8 | def server(url: str) -> str:
9 | return urlparse(url).netloc
10 |
11 |
12 | def _update(url: str, replace: _Q) -> None:
13 | update_one_remote({"server": server(url)}, replace, upsert=True)
14 |
15 |
16 | # TODO(tsileo): track receive (and the user agent to help debug issues)
17 |
18 |
19 | def track_successful_send(url: str) -> None:
20 | now_ = now()
21 | _update(
22 | url,
23 | {
24 | "$inc": {"successful_send": 1},
25 | "$set": {
26 | "last_successful_contact": now_,
27 | "last_successful_send": now_,
28 | "last_contact": now_,
29 | },
30 | },
31 | )
32 | return None
33 |
34 |
35 | def track_failed_send(url: str) -> None:
36 | now_ = now()
37 | _update(url, {"$inc": {"failed_send": 1}, "$set": {"last_contact": now_}})
38 | return None
39 |
--------------------------------------------------------------------------------
/core/db.py:
--------------------------------------------------------------------------------
1 | from enum import Enum
2 | from enum import unique
3 | from typing import Any
4 | from typing import Dict
5 | from typing import Iterable
6 | from typing import Optional
7 |
8 | from config import DB
9 |
10 | _Q = Dict[str, Any]
11 | _D = Dict[str, Any]
12 | _Doc = Optional[_D]
13 |
14 |
15 | @unique
16 | class CollectionName(Enum):
17 | ACTIVITIES = "activities"
18 | REMOTE = "remote"
19 |
20 |
21 | def find_one_activity(q: _Q) -> _Doc:
22 | return DB[CollectionName.ACTIVITIES.value].find_one(q)
23 |
24 |
25 | def find_activities(q: _Q) -> Iterable[_D]:
26 | return DB[CollectionName.ACTIVITIES.value].find(q)
27 |
28 |
29 | def update_one_activity(q: _Q, update: _Q) -> bool:
30 | return DB[CollectionName.ACTIVITIES.value].update_one(q, update).matched_count == 1
31 |
32 |
33 | def update_many_activities(q: _Q, update: _Q) -> None:
34 | DB[CollectionName.ACTIVITIES.value].update_many(q, update)
35 |
36 |
37 | def update_one_remote(filter_: _Q, update: _Q, upsert: bool = False) -> None:
38 | DB[CollectionName.REMOTE.value].update_one(filter_, update, upsert)
39 |
--------------------------------------------------------------------------------
/utils/blacklist.py:
--------------------------------------------------------------------------------
1 | import logging
2 | from typing import Any
3 | from typing import Dict
4 | from urllib.parse import urlparse
5 |
6 | import config
7 |
8 | logger = logging.getLogger(__name__)
9 |
10 |
11 | def is_url_blacklisted(url: str) -> bool:
12 | try:
13 | return urlparse(url).netloc in config.BLACKLIST
14 | except Exception:
15 | logger.exception(f"failed to blacklist for {url}")
16 | return False
17 |
18 |
19 | def is_blacklisted(data: Dict[str, Any]) -> bool:
20 | """Returns True if the activity is coming/or referencing a blacklisted host."""
21 | if (
22 | "id" in data
23 | and is_url_blacklisted(data["id"])
24 | or (
25 | "object" in data
26 | and isinstance(data["object"], dict)
27 | and "id" in data["object"]
28 | and is_url_blacklisted(data["object"]["id"])
29 | )
30 | or (
31 | "object" in data
32 | and isinstance(data["object"], str)
33 | and is_url_blacklisted(data["object"])
34 | )
35 | ):
36 | return True
37 |
38 | return False
39 |
--------------------------------------------------------------------------------
/templates/login.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}Login - {{ config.NAME }}{% endblock %}
4 | {% block header %}
5 |
15 | {% endblock %}
16 | {% block content %}
17 |
18 |
19 |
28 |
29 |
30 | {% if u2f_enabled %}
31 |
45 | {% endif %}
46 | {% endblock %}
47 |
--------------------------------------------------------------------------------
/templates/followers.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}Followers - {{ config.NAME }}{% endblock %}
4 | {% block header %}
5 | {% endblock %}
6 | {% block content %}
7 |
8 | {% include "header.html" %}
9 |
10 |
11 |
32 |
33 | {% endblock %}
34 | {% block links %}
35 |
36 | {{ utils.display_pagination_links(older_than, newer_than) }}{% endblock %}
37 |
--------------------------------------------------------------------------------
/templates/liked.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block content %}
4 |
12 | {% for meta in followers_data %}
13 | {% set follower = meta.actor %}
14 | {% if session.logged_in %}
15 |
30 |
31 |
16 | profile
17 |
18 | {% if meta.notification_follows_back %}
19 |
20 | {% endif %}
21 |
22 |
23 | {% endif %}
24 |
25 | {{ utils.display_actor_inline(follower, size=80) }}
26 |
27 | {% endfor %}
28 | {{ utils.display_pagination(older_than, newer_than) }}
29 |
5 |
6 |
7 | {% include "header.html" %}
8 |
9 |
31 | {% endblock %}
32 | {% block links %}
33 |
34 | {{ utils.display_pagination_links(older_than, newer_than) }}{% endblock %}
35 |
--------------------------------------------------------------------------------
/templates/admin_indieauth.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}IndieAuth logs - {{ config.NAME }}{% endblock %}
4 | {% block content %}
5 |
10 | {% for item in liked %}
11 | {% if session.logged_in %}
12 |
29 |
30 |
13 |
19 |
20 |
21 | {% endif %}
22 | {% if item.meta.object %}
23 | {{ utils.display_note(item.meta.object, meta=item.meta) }}
24 | {% endif %}
25 | {% endfor %}
26 |
27 | {{ utils.display_pagination(older_than, newer_than) }}
28 |
6 | {% include "header.html" %}
7 |
29 | {% endblock %}
30 |
--------------------------------------------------------------------------------
/utils/key.py:
--------------------------------------------------------------------------------
1 | import binascii
2 | import os
3 | from typing import Callable
4 |
5 | from little_boxes.key import Key
6 |
7 | KEY_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "config")
8 |
9 |
10 | def _new_key() -> str:
11 | return binascii.hexlify(os.urandom(32)).decode("utf-8")
12 |
13 |
14 | def get_secret_key(name: str, new_key: Callable[[], str] = _new_key) -> str:
15 | """Loads or generates a cryptographic key."""
16 | key_path = os.path.join(KEY_DIR, f"{name}.key")
17 | if not os.path.exists(key_path):
18 | k = new_key()
19 | with open(key_path, "w+") as f:
20 | f.write(k)
21 | return k
22 |
23 | with open(key_path) as f:
24 | return f.read()
25 |
26 |
27 | def get_key(owner: str, _id: str, user: str, domain: str) -> Key:
28 | """"Loads or generates an RSA key."""
29 | k = Key(owner, _id)
30 | user = user.replace(".", "_")
31 | domain = domain.replace(".", "_")
32 | key_path = os.path.join(KEY_DIR, f"key_{user}_{domain}.pem")
33 | if os.path.isfile(key_path):
34 | with open(key_path) as f:
35 | privkey_pem = f.read()
36 | k.load(privkey_pem)
37 | else:
38 | k.new()
39 | with open(key_path, "w") as f:
40 | f.write(k.privkey_pem)
41 |
42 | return k
43 |
--------------------------------------------------------------------------------
/templates/note_debug.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}{{ config.NAME }}: "{{ note.activity.object.content | html2plaintext | truncate(50) }}"{% endblock %}
4 | {% block header %}
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 | {% endblock %}
16 | {% block content %}
17 |
8 |
27 |
28 | IndieAuth logs
9 |-
10 | {% for action in indieauth_actions %}
11 |
- {{action.ts|format_ts}}
12 | {% if action.verified_by == "id" %}Authentication {% else %}Authorization {% endif %}
13 | request by {{ action.client_id }}
14 | / {{action.ip_address}} {% if action.geoip %}({{action.geoip}}){% endif %}
15 | as {{action.me}}
16 | ({% if action.scope %}scope=
{{action.scope}},{% endif %}redirect_uri={{action.redirect_uri}}). 17 | {% if action.token_expires %} 18 |
19 | The token{{action.token[:20]}}...20 | {% if action.token_expires|gt_ts%}has expired on{% else %}expires{% endif %} {{ action.token_expires|format_ts }} 21 | {% endif %} 22 | 23 |
24 | {% endfor %}
25 |
18 | {% include "header.html" %}
19 |
21 | {% endblock %}
22 | {% block links %}{% endblock %}
23 |
--------------------------------------------------------------------------------
/templates/indieauth_flow.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block header %}
4 | {% endblock %}
5 | {% block content %}
6 | {{ thread | remove_mongo_id | tojson(indent=4) }}
7 |
8 |
41 | {% endblock %}
42 |
--------------------------------------------------------------------------------
/templates/note.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}{{ config.NAME }}{{ note.activity.object | get_text | html2plaintext | trim | truncate(50) }}"{% endblock %}
4 | {% block header %}
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | {% endblock %}
17 | {% block content %}
18 |
9 | {% if client.logo %}
10 |
21 |
22 |
39 |
40 |
11 | 
12 |
13 | {% endif %}
14 |
15 |
20 |
16 | {{ client.name }}
17 |
19 | wants you to login as {{ me }}
18 |
19 | {% if request.path != "/admin/thread" %}
20 | {% include "header.html" %}
21 | {% endif %}
22 |
23 | {{ utils.display_thread(thread, likes=likes, shares=shares) }}
24 |
25 |
26 | {% endblock %}
27 | {% block links %}{% endblock %}
28 |
--------------------------------------------------------------------------------
/utils/webmentions.py:
--------------------------------------------------------------------------------
1 | import logging
2 | from typing import Optional
3 | from urllib.parse import urlparse
4 |
5 | import requests
6 | from bs4 import BeautifulSoup
7 | from little_boxes.urlutils import is_url_valid
8 |
9 | logger = logging.getLogger(__name__)
10 |
11 |
12 | def _make_abs(url: Optional[str], parent: str) -> Optional[str]:
13 | if url is None:
14 | return None
15 |
16 | if url.startswith("http"):
17 | return url
18 |
19 | return (
20 | urlparse(parent)._replace(path=url, params="", query="", fragment="").geturl()
21 | )
22 |
23 |
24 | def _discover_webmention_endoint(url: str) -> Optional[str]:
25 | try:
26 | resp = requests.get(url, timeout=3)
27 | except Exception:
28 | return None
29 |
30 | for k, v in resp.links.items():
31 | if "webmention" in k:
32 | return _make_abs(resp.links[k].get("url"), url)
33 |
34 | soup = BeautifulSoup(resp.text, "html5lib")
35 | wlinks = soup.find_all(["link", "a"], attrs={"rel": "webmention"})
36 | for wlink in wlinks:
37 | if "href" in wlink.attrs:
38 | return _make_abs(wlink.attrs["href"], url)
39 |
40 | return None
41 |
42 |
43 | def discover_webmention_endpoint(url: str) -> Optional[str]:
44 | """Discover the Webmention endpoint of a given URL, if any.
45 |
46 | Passes all the tests at https://webmention.rocks!
47 |
48 | """
49 | wurl = _discover_webmention_endoint(url)
50 | if wurl is None:
51 | return None
52 | if not is_url_valid(wurl):
53 | return None
54 | return wurl
55 |
--------------------------------------------------------------------------------
/templates/tags.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}#{{ tag }} - {{ config.NAME }}{% endblock %}
4 | {% block header %}
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 | {% endblock %}
18 | {% block content %}
19 |
20 |
21 |
22 | {% include "header.html" %}
23 |
24 |
31 |
32 | {% endblock %}
33 | {% block links %}
34 |
35 | {% endblock %}
36 |
--------------------------------------------------------------------------------
/utils/migrations.py:
--------------------------------------------------------------------------------
1 | """Automatic migration tools for the da:ta stored in MongoDB."""
2 | import logging
3 | from abc import ABC
4 | from abc import abstractmethod
5 | from typing import List
6 | from typing import Type
7 |
8 | from config import DB
9 |
10 | logger = logging.getLogger(__name__)
11 |
12 | # Used to keep track of all the defined migrations
13 | _MIGRATIONS: List[Type["Migration"]] = []
14 |
15 |
16 | def perform() -> None:
17 | """Perform all the defined migration."""
18 | for migration in _MIGRATIONS:
19 | migration().perform()
20 |
21 |
22 | class Migration(ABC):
23 | """Abstract class for migrations."""
24 |
25 | def __init__(self) -> None:
26 | self.name = self.__class__.__qualname__
27 | self._col = DB.migrations
28 |
29 | def __init_subclass__(cls, **kwargs):
30 | super().__init_subclass__(**kwargs)
31 | _MIGRATIONS.append(cls)
32 |
33 | def _apply(self) -> None:
34 | self._col.insert_one({"name": self.name})
35 |
36 | def _reset(self) -> None:
37 | self._col.delete_one({"name": self.name})
38 |
39 | def _is_applied(self) -> bool:
40 | return bool(self._col.find_one({"name": self.name}))
41 |
42 | @abstractmethod
43 | def migrate(self) -> None:
44 | """Expected to be implemented by actual migrations."""
45 | pass
46 |
47 | def perform(self) -> None:
48 | if self._is_applied():
49 | logger.info(f"Skipping migration {self.name} (already applied)")
50 | return
51 |
52 | logger.info(f"Performing migration {self.name}...")
53 | self.migrate()
54 |
55 | self._apply()
56 | logger.info("Done")
57 |
--------------------------------------------------------------------------------
/utils/emojis.py:
--------------------------------------------------------------------------------
1 | import mimetypes
2 | import re
3 | from datetime import datetime
4 | from pathlib import Path
5 | from typing import Any
6 | from typing import Dict
7 | from typing import List
8 | from typing import Set
9 |
10 | from little_boxes import activitypub as ap
11 |
12 | EMOJI_REGEX = re.compile(r"(:[\d\w]+:)")
13 |
14 | EMOJIS: Dict[str, Dict[str, Any]] = {}
15 | EMOJIS_BY_NAME: Dict[str, Dict[str, Any]] = {}
16 |
17 |
18 | def _load_emojis(root_dir: Path, base_url: str) -> None:
19 | if EMOJIS:
20 | return
21 | for emoji in (root_dir / "static" / "emojis").iterdir():
22 | mt = mimetypes.guess_type(emoji.name)[0]
23 | if mt and mt.startswith("image/"):
24 | name = emoji.name.split(".")[0]
25 | ap_emoji = dict(
26 | type=ap.ActivityType.EMOJI.value,
27 | name=f":{name}:",
28 | updated=ap.format_datetime(datetime.fromtimestamp(0.0).astimezone()),
29 | id=f"{base_url}/emoji/{name}",
30 | icon={
31 | "mediaType": mt,
32 | "type": ap.ActivityType.IMAGE.value,
33 | "url": f"{base_url}/static/emojis/{emoji.name}",
34 | },
35 | )
36 | EMOJIS[emoji.name] = ap_emoji
37 | EMOJIS_BY_NAME[ap_emoji["name"]] = ap_emoji
38 |
39 |
40 | def tags(content: str) -> List[Dict[str, Any]]:
41 | tags: List[Dict[str, Any]] = []
42 | added: Set[str] = set()
43 | for e in re.findall(EMOJI_REGEX, content):
44 | if e not in added and e in EMOJIS_BY_NAME:
45 | tags.append(EMOJIS_BY_NAME[e])
46 | added.add(e)
47 |
48 | return tags
49 |
--------------------------------------------------------------------------------
/templates/header.html:
--------------------------------------------------------------------------------
1 | #{{ tag }}
25 |
26 | {% for item in outbox_data %}
27 | {{ utils.display_note(item.activity.object, meta=item.meta) }}
28 | {% endfor %}
29 |
30 |
9 |
10 |
61 | {% endblock %}
62 |
--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | SHELL := /bin/bash
2 | PYTHON=python
3 | SETUP_WIZARD_IMAGE=microblogpub-setup-wizard:latest
4 | PWD=$(shell pwd)
5 |
6 | # Build the config (will error if an existing config/me.yml is found) via a Docker container
7 | .PHONY: config
8 | config:
9 | # Build the container for the setup wizard on-the-fly
10 | cd setup_wizard && docker build . -t $(SETUP_WIZARD_IMAGE)
11 | # Run and remove instantly
12 | -docker run -e MICROBLOGPUB_WIZARD_PROJECT_NAME --rm -it --volume $(PWD):/app/out $(SETUP_WIZARD_IMAGE)
13 | # Finally, remove the tagged image
14 | docker rmi $(SETUP_WIZARD_IMAGE)
15 |
16 | # Reload the federation test instances (for local dev)
17 | .PHONY: reload-fed
18 | reload-fed:
19 | docker build . -t microblogpub:latest
20 | docker-compose -p instance2 -f docker-compose-tests.yml stop
21 | docker-compose -p instance1 -f docker-compose-tests.yml stop
22 | WEB_PORT=5006 CONFIG_DIR=./tests/fixtures/instance1/config docker-compose -p instance1 -f docker-compose-tests.yml up -d --force-recreate --build
23 | WEB_PORT=5007 CONFIG_DIR=./tests/fixtures/instance2/config docker-compose -p instance2 -f docker-compose-tests.yml up -d --force-recreate --build
24 |
25 | # Reload the local dev instance
26 | .PHONY: reload-dev
27 | reload-dev:
28 | docker build . -t microblogpub:latest
29 | docker-compose -f docker-compose-dev.yml up -d --force-recreate
30 |
31 | # Build the microblogpub Docker image
32 | .PHONY: microblogpub
33 | microblogpub:
34 | # Update microblog.pub
35 | git pull
36 | # Rebuild the Docker image
37 | docker build . --no-cache -t microblogpub:latest
38 |
39 | .PHONY: css
40 | css:
41 | # Download pure.css if needed
42 | if [[ ! -f static/pure.css ]]; then curl https://unpkg.com/purecss@1.0.1/build/pure-min.css > static/pure.css; fi
43 | # Download the emojis from twemoji if needded
44 | if [[ ! -d static/twemoji ]]; then wget https://github.com/twitter/twemoji/archive/v12.1.2.tar.gz && tar xvzf v12.1.2.tar.gz && mv twemoji-12.1.2/assets/svg static/twemoji && rm -rf twemoji-12.1.2 && rm -f v12.1.2.tar.gz; fi
45 |
46 | # Run the docker-compose project locally (will perform a update if the project is already running)
47 | .PHONY: run
48 | run: microblogpub css
49 | # (poussetaches and microblogpub Docker image will updated)
50 | # Update MongoDB
51 | docker pull mongo:3
52 | docker pull poussetaches/poussetaches
53 | # Restart the project
54 | docker-compose stop
55 | docker-compose up -d --force-recreate --build
56 |
--------------------------------------------------------------------------------
/utils/nodeinfo.py:
--------------------------------------------------------------------------------
1 | from enum import Enum
2 | from enum import unique
3 | from functools import lru_cache
4 | from typing import Optional
5 |
6 | import little_boxes.activitypub as ap
7 | import requests
8 |
9 |
10 | @unique
11 | class SoftwareName(Enum):
12 | UNKNOWN = "unknown"
13 | MASTODON = "mastodon"
14 | MICROBLOGPUB = "microblogpub"
15 |
16 |
17 | def _get_nodeinfo_url(server: str) -> Optional[str]:
18 | backend = ap.get_backend()
19 | for scheme in {"https", "http"}:
20 | try:
21 | resp = requests.get(
22 | f"{scheme}://{server}/.well-known/nodeinfo",
23 | timeout=10,
24 | allow_redirects=True,
25 | headers={"User-Agent": backend.user_agent()},
26 | )
27 | resp.raise_for_status()
28 | data = resp.json()
29 | for link in data.get("links", []):
30 | return link["href"]
31 | except requests.HTTPError:
32 | return None
33 | except requests.RequestException:
34 | continue
35 |
36 | return None
37 |
38 |
39 | def _try_mastodon_api(server: str) -> bool:
40 | for scheme in {"https", "http"}:
41 | try:
42 | resp = requests.get(f"{scheme}://{server}/api/v1/instance")
43 | resp.raise_for_status()
44 | if resp.json():
45 | return True
46 | except requests.HTTPError:
47 | return False
48 | except requests.RequestException:
49 | continue
50 |
51 | return False
52 |
53 |
54 | @lru_cache(2048)
55 | def get_software_name(server: str) -> str:
56 | backend = ap.get_backend()
57 | nodeinfo_endpoint = _get_nodeinfo_url(server)
58 | if nodeinfo_endpoint:
59 | try:
60 | resp = requests.get(
61 | nodeinfo_endpoint,
62 | timeout=10,
63 | headers={"User-Agent": backend.user_agent()},
64 | )
65 | resp.raise_for_status()
66 | software_name = resp.json().get("software", {}).get("name")
67 | if software_name:
68 | return software_name
69 |
70 | return SoftwareName.UNKNOWN.value
71 | except requests.RequestException:
72 | return SoftwareName.UNKNOWN.value
73 |
74 | if _try_mastodon_api(server):
75 | return SoftwareName.MASTODON.value
76 |
77 | return SoftwareName.UNKNOWN.value
78 |
--------------------------------------------------------------------------------
/setup_wizard/wizard.py:
--------------------------------------------------------------------------------
1 | """Basic wizard for setting up microblog.pub configuration files."""
2 | import binascii
3 | import os
4 | import sys
5 | from pathlib import Path
6 |
7 | import bcrypt
8 | from markdown import markdown
9 | from prompt_toolkit import prompt
10 |
11 |
12 | def main() -> None:
13 | print("Welcome to microblog.pub setup wizard\n")
14 |
15 | config_file = Path("/app/out/config/me.yml")
16 | env_file = Path("/app/out/.env")
17 |
18 | if config_file.exists():
19 | # Spit out the relative path for the "config artifacts"
20 | rconfig_file = "config/me.yml"
21 | print(
22 | f"Existing setup detected, please delete {rconfig_file} before restarting the wizard"
23 | )
24 | sys.exit(2)
25 |
26 | dat = {}
27 | print("Your identity will be @{username}@{domain}")
28 | dat["domain"] = prompt("domain: ")
29 | dat["username"] = prompt("username: ")
30 | dat["pass"] = bcrypt.hashpw(
31 | prompt("password: ", is_password=True).encode(), bcrypt.gensalt()
32 | ).decode()
33 | dat["name"] = prompt("name (e.g. John Doe): ")
34 | dat["summary"] = markdown(
35 | prompt(
36 | "summary (short description, in markdown, press [ESC] then [ENTER] to submit):\n",
37 | multiline=True,
38 | )
39 | )
40 | dat["https"] = True
41 | proto = "https"
42 | yn = ""
43 | while yn not in ["y", "n"]:
44 | yn = prompt("will the site be served via https? (y/n): ", default="y").lower()
45 | if yn == "n":
46 | dat["https"] = False
47 | proto = "http"
48 |
49 | dat["icon_url"] = prompt(
50 | "icon URL: ", default=f'{proto}://{dat["domain"]}/static/nopic.png'
51 | )
52 |
53 | out = ""
54 | for k, v in dat.items():
55 | out += f"{k}: {v!r}\n"
56 |
57 | with config_file.open("w") as f:
58 | f.write(out)
59 |
60 | proj_name = os.getenv("MICROBLOGPUB_WIZARD_PROJECT_NAME", "microblogpub")
61 |
62 | env = {
63 | "WEB_PORT": 5005,
64 | "CONFIG_DIR": "./config",
65 | "DATA_DIR": "./data",
66 | "POUSSETACHES_AUTH_KEY": binascii.hexlify(os.urandom(32)).decode(),
67 | "COMPOSE_PROJECT_NAME": proj_name,
68 | }
69 |
70 | out2 = ""
71 | for k, v in env.items():
72 | out2 += f"{k}={v}\n"
73 |
74 | with env_file.open("w") as f:
75 | f.write(out2)
76 |
77 | print("Done")
78 | sys.exit(0)
79 |
80 |
81 | if __name__ == "__main__":
82 | try:
83 | main()
84 | except KeyboardInterrupt:
85 | print("Aborted")
86 | sys.exit(1)
87 |
--------------------------------------------------------------------------------
/templates/following.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}Following - {{ config.NAME }}{% endblock %}
4 | {% block header %}
5 | {% endblock %}
6 | {% block content %}
7 |
11 |
60 | Lists and its members are private.
12 |New List
13 | 19 | 20 |Lists
21 |Manage list members in the Following section
22 | 23 |-
24 | {% for l in lists %}
25 |
- {{ l.name }} 26 | {% endfor %} 27 |
Manage lists
30 | {% for l in lists %} 31 |{{ l.name }} {{ l.members | length }} members
32 | 38 | 39 |
40 |
41 | {% for member in l.members %}
42 |
59 |
43 |
50 |
51 |
52 |
53 | {{ utils.display_actor_inline(member | get_actor, size=80) }}
54 |
55 | {% endfor %}
56 |
57 | {% endfor %}
58 |
8 | {% include "header.html" %}
9 |
10 |
68 | {% endblock %}
69 | {% block links %}
70 |
71 | {{ utils.display_pagination_links(older_than, newer_than) }}{% endblock %}
72 |
--------------------------------------------------------------------------------
/templates/lookup.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}Lookup - {{ config.NAME }}{% endblock %}
4 | {% block content %}
5 |
11 | {% for (follow_id, meta) in following_data %}
12 | {% set follow = meta.object %}
13 | {% if session.logged_in %}
14 |
66 |
67 |
15 | profile
16 |
22 | {% if meta.notification_follows_back %}
23 |
24 | {% endif %}
25 |
26 | {% if lists %}
27 |
41 | {% endif %}
42 |
43 | {% for l in lists %}
44 | {% if follow.id in l.members %}
45 |
51 |
52 |
53 | {% endif %}
54 | {% endfor %}
55 |
56 |
57 |
58 |
59 | {% endif %}
60 |
61 | {{ utils.display_actor_inline(follow, size=80) }}
62 |
63 | {% endfor %}
64 | {{ utils.display_pagination(older_than, newer_than) }}
65 |
6 |
65 | {% endblock %}
66 |
--------------------------------------------------------------------------------
/blueprints/well_known.py:
--------------------------------------------------------------------------------
1 | import mimetypes
2 | from typing import Any
3 |
4 | import flask
5 | from flask import abort
6 | from flask import request
7 | from little_boxes import activitypub as ap
8 |
9 | import config
10 | from config import DB
11 | from core.meta import Box
12 | from core.shared import jsonify
13 |
14 | blueprint = flask.Blueprint("well_known", __name__)
15 |
16 |
17 | @blueprint.route("/.well-known/webfinger")
18 | def wellknown_webfinger() -> Any:
19 | """Exposes/servers WebFinger data."""
20 | resource = request.args.get("resource")
21 | if resource not in [f"acct:{config.USERNAME}@{config.DOMAIN}", config.ID]:
22 | abort(404)
23 |
24 | out = {
25 | "subject": f"acct:{config.USERNAME}@{config.DOMAIN}",
26 | "aliases": [config.ID],
27 | "links": [
28 | {
29 | "rel": "http://webfinger.net/rel/profile-page",
30 | "type": "text/html",
31 | "href": config.ID,
32 | },
33 | {"rel": "self", "type": "application/activity+json", "href": config.ID},
34 | {
35 | "rel": "http://ostatus.org/schema/1.0/subscribe",
36 | "template": config.BASE_URL + "/authorize_follow?profile={uri}",
37 | },
38 | {"rel": "magic-public-key", "href": config.KEY.to_magic_key()},
39 | {
40 | "href": config.ICON_URL,
41 | "rel": "http://webfinger.net/rel/avatar",
42 | "type": mimetypes.guess_type(config.ICON_URL)[0],
43 | },
44 | ],
45 | }
46 |
47 | return jsonify(out, "application/jrd+json; charset=utf-8")
48 |
49 |
50 | @blueprint.route("/.well-known/nodeinfo")
51 | def wellknown_nodeinfo() -> Any:
52 | """Exposes the NodeInfo endpoint (http://nodeinfo.diaspora.software/)."""
53 | return jsonify(
54 | {
55 | "links": [
56 | {
57 | "rel": "http://nodeinfo.diaspora.software/ns/schema/2.1",
58 | "href": f"{config.ID}/nodeinfo",
59 | }
60 | ]
61 | }
62 | )
63 |
64 |
65 | @blueprint.route("/nodeinfo")
66 | def nodeinfo() -> Any:
67 | """NodeInfo endpoint."""
68 | q = {
69 | "box": Box.OUTBOX.value,
70 | "meta.deleted": False,
71 | "type": {"$in": [ap.ActivityType.CREATE.value, ap.ActivityType.ANNOUNCE.value]},
72 | }
73 |
74 | out = {
75 | "version": "2.1",
76 | "software": {
77 | "name": "microblogpub",
78 | "version": config.VERSION,
79 | "repository": "https://github.com/tsileo/microblog.pub",
80 | },
81 | "protocols": ["activitypub"],
82 | "services": {"inbound": [], "outbound": []},
83 | "openRegistrations": False,
84 | "usage": {"users": {"total": 1}, "localPosts": DB.activities.count(q)},
85 | "metadata": {
86 | "nodeName": f"@{config.USERNAME}@{config.DOMAIN}",
87 | "version": config.VERSION,
88 | "versionDate": config.VERSION_DATE,
89 | },
90 | }
91 |
92 | return jsonify(
93 | out,
94 | "application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.1#",
95 | )
96 |
--------------------------------------------------------------------------------
/templates/layout.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
7 |
8 |
64 | Interact with an ActivityPub object via its URL or look for a user using @user@domain.tld
9 | 10 | 14 | 15 | {% if data %} 16 | {% set data = data.to_dict() %} 17 |
18 | {% if data | has_actor_type %}
19 |
61 | {% endif %}
62 |
63 |
20 | {% if following %}
21 | profile
22 |
28 |
34 | {% else %}
35 |
41 | {% endif %}
42 | {% if follower %}{% endif %}
43 |
44 |
45 |
46 | {{ utils.display_actor_inline(data, size=80) }}
47 |
48 | {% elif data | has_type('Create') %}
49 | {{ utils.display_note(data.object, meta=meta) }}
50 | {% elif data | has_type(['Note', 'Article', 'Video', 'Audio', 'Page', 'Question']) %}
51 | {{ utils.display_note(data, meta=meta) }}
52 | {% elif data | has_type('Announce') %}
53 | {% set boost_actor = meta.actor %}
54 | 55 | 56 |
57 | {{ utils.display_note(meta.object, meta=meta) }} 58 | 59 | {% endif %} 60 |
55 | {% block content %}{% endblock %}
56 |
57 |
62 |
63 |
64 |
--------------------------------------------------------------------------------
/templates/admin_tasks.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block title %}Tasks - {{ config.NAME }}{% endblock %}
4 | {% block content %}
5 |
6 | {% include "header.html" %}
7 |
116 | {% endblock %}
117 |
--------------------------------------------------------------------------------
/core/indexes.py:
--------------------------------------------------------------------------------
1 | import pymongo
2 |
3 | from config import DB
4 | from config import MEDIA_CACHE
5 | from core.meta import MetaKey
6 | from core.meta import _meta
7 |
8 |
9 | def create_indexes():
10 | if "trash" not in DB.collection_names():
11 | DB.create_collection("trash", capped=True, size=50 << 20) # 50 MB
12 |
13 | if "activities" in DB.collection_names():
14 | DB.command("compact", "activities")
15 |
16 | try:
17 | MEDIA_CACHE.fs._GridFS__database.command("compact", "fs.files")
18 | MEDIA_CACHE.fs._GridFS__database.command("compact", "fs.chunks")
19 | except Exception:
20 | pass
21 |
22 | DB.activities.create_index([(_meta(MetaKey.NOTIFICATION), pymongo.ASCENDING)])
23 | DB.activities.create_index(
24 | [(_meta(MetaKey.NOTIFICATION_UNREAD), pymongo.ASCENDING)]
25 | )
26 | DB.activities.create_index([("remote_id", pymongo.ASCENDING)])
27 | DB.activities.create_index([("meta.actor_id", pymongo.ASCENDING)])
28 | DB.activities.create_index([("meta.object_id", pymongo.ASCENDING)])
29 | DB.activities.create_index([("meta.mentions", pymongo.ASCENDING)])
30 | DB.activities.create_index([("meta.hashtags", pymongo.ASCENDING)])
31 | DB.activities.create_index([("meta.thread_root_parent", pymongo.ASCENDING)])
32 | DB.activities.create_index(
33 | [
34 | ("meta.thread_root_parent", pymongo.ASCENDING),
35 | ("meta.deleted", pymongo.ASCENDING),
36 | ]
37 | )
38 | DB.activities.create_index(
39 | [("activity.object.id", pymongo.ASCENDING), ("meta.deleted", pymongo.ASCENDING)]
40 | )
41 | DB.activities.create_index(
42 | [("meta.object_id", pymongo.ASCENDING), ("type", pymongo.ASCENDING)]
43 | )
44 |
45 | # Index for the block query
46 | DB.activities.create_index(
47 | [
48 | ("box", pymongo.ASCENDING),
49 | ("type", pymongo.ASCENDING),
50 | ("meta.undo", pymongo.ASCENDING),
51 | ]
52 | )
53 |
54 | # Index for count queries
55 | DB.activities.create_index(
56 | [
57 | ("box", pymongo.ASCENDING),
58 | ("type", pymongo.ASCENDING),
59 | ("meta.undo", pymongo.ASCENDING),
60 | ("meta.deleted", pymongo.ASCENDING),
61 | ]
62 | )
63 |
64 | DB.activities.create_index([("box", pymongo.ASCENDING)])
65 |
66 | # Outbox query
67 | DB.activities.create_index(
68 | [
69 | ("box", pymongo.ASCENDING),
70 | ("type", pymongo.ASCENDING),
71 | ("meta.undo", pymongo.ASCENDING),
72 | ("meta.deleted", pymongo.ASCENDING),
73 | ("meta.public", pymongo.ASCENDING),
74 | ]
75 | )
76 |
77 | DB.activities.create_index(
78 | [
79 | ("type", pymongo.ASCENDING),
80 | ("activity.object.type", pymongo.ASCENDING),
81 | ("activity.object.inReplyTo", pymongo.ASCENDING),
82 | ("meta.deleted", pymongo.ASCENDING),
83 | ]
84 | )
85 |
86 | # For the is_actor_icon_cached query
87 | MEDIA_CACHE.fs._GridFS__files.create_index([("url", 1), ("kind", 1)])
88 |
89 | # Replies index
90 | DB.replies.create_index([("remote_id", pymongo.ASCENDING)])
91 | DB.replies.create_index([("meta.thread_root_parent", pymongo.ASCENDING)])
92 | DB.replies.create_index(
93 | [
94 | ("meta.thread_root_parent", pymongo.ASCENDING),
95 | ("meta.deleted", pymongo.ASCENDING),
96 | ]
97 | )
98 |
--------------------------------------------------------------------------------
/.drone.yml:
--------------------------------------------------------------------------------
1 | ---
2 | priviliged: true # Needed for Docker in Docker
3 | kind: pipeline
4 | name: default
5 | steps:
6 | # Run Mypy/Flake8/black linters before any further work is done
7 | - name: lint
8 | image: python:3
9 | commands:
10 | - pip install -U pip
11 | - pip install mypy flake8 black
12 | - black --check .
13 | - flake8
14 | - mypy --ignore-missing-imports .
15 | - mypy --ignore-missing-imports setup_wizard
16 |
17 | # Build the container images we need for the test suite
18 | - name: build_containers
19 | image: docker:dind
20 | environment:
21 | DOCKER_HOST: tcp://docker:2375
22 | commands:
23 | - apk update && apk upgrade && apk add --no-cache bash git openssh curl
24 | - docker network create fede
25 | - docker pull mongo
26 | - docker pull poussetaches/poussetaches
27 | - docker build . -t microblogpub:latest
28 |
29 | # Run poussetaches (will be shared by the two microblog.pub instances) "in the background"
30 | - name: run_poussetaches
31 | image: docker:dind
32 | detach: true
33 | environment:
34 | DOCKER_HOST: tcp://docker:2375
35 | POUSSETACHES_AUTH_KEY: lol
36 | commands:
37 | - docker run -p 7991:7991 --net fede -e POUSSETACHES_AUTH_KEY --name poussetaches poussetaches/poussetaches
38 |
39 | # Run MongoDB (will be shared by the two microblog.pub instances) "in the background"
40 | - name: run_mongodb
41 | image: docker:dind
42 | detach: true
43 | environment:
44 | DOCKER_HOST: tcp://docker:2375
45 | commands:
46 | - docker run -p 27017:27017 --net fede --name mongo mongo
47 |
48 | # Run a first microblog.pub instance "in the background"
49 | - name: microblogpub_instance1
50 | image: docker:dind
51 | detach: true
52 | environment:
53 | DOCKER_HOST: tcp://docker:2375
54 | MICROBLOGPUB_DEBUG: 1
55 | MICROBLOGPUB_POUSSETACHES_HOST: http://poussetaches:7991
56 | MICROBLOGPUB_INTERNAL_HOST: http://instance1_web:5005
57 | MICROBLOGPUB_MONGODB_HOST: mongo:27017
58 | POUSSETACHES_AUTH_KEY: lol
59 | commands:
60 | - sleep 5
61 | - 'docker run -p 5006:5005 --net fede -v "`pwd`/tests/fixtures/instance1/config:/app/config" -e MICROBLOGPUB_DEBUG -e MICROBLOGPUB_INTERNAL_HOST -e MICROBLOGPUB_MONGODB_HOST -e MICROBLOGPUB_POUSSETACHES_HOST -e POUSSETACHES_AUTH_KEY --name instance1_web microblogpub'
62 |
63 | # Run the second microblog.pub instance "in the background"
64 | - name: microblogpub_instance2
65 | image: docker:dind
66 | detach: true
67 | environment:
68 | DOCKER_HOST: tcp://docker:2375
69 | MICROBLOGPUB_DEBUG: 1
70 | MICROBLOGPUB_POUSSETACHES_HOST: http://poussetaches:7991
71 | MICROBLOGPUB_INTERNAL_HOST: http://instance2_web:5005
72 | MICROBLOGPUB_MONGODB_HOST: mongo:27017
73 | POUSSETACHES_AUTH_KEY: lol
74 | commands:
75 | - 'docker run -p 5007:5005 --net fede -v "`pwd`/tests/fixtures/instance2/config:/app/config" -e MICROBLOGPUB_DEBUG -e MICROBLOGPUB_INTERNAL_HOST -e MICROBLOGPUB_MONGODB_HOST -e MICROBLOGPUB_POUSSETACHES_HOST -e POUSSETACHES_AUTH_KEY --name instance2_web microblogpub'
76 |
77 | # Run some tests against the two instances to ensure federation is working
78 | - name: federation_test
79 | image: python:3
80 | commands:
81 | - pip install -U pip
82 | - pip install -r dev-requirements.txt
83 | # Federation tests (with two local instances)
84 | - python -m pytest -v -s --ignore data -k federatio
85 |
86 | # Setup the services needed to do some "Docker in Docker" (or dind)
87 | services:
88 | - name: docker
89 | image: docker:dind
90 | privileged: true
91 | ---
92 | kind: signature
93 | hmac: ae911176117298c18ecfcd95fbdbd62304c5f32462b42f2aefdd5a5b834fed60
94 |
95 | ...
96 |
--------------------------------------------------------------------------------
/templates/index.html:
--------------------------------------------------------------------------------
1 | {% extends "layout.html" %}
2 | {% import 'utils.html' as utils %}
3 | {% block header %}
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 | {% endblock %}
17 | {% block content %}
18 |
8 |
9 |
11 |
12 |
35 |
36 |
38 |
39 |
60 |
61 |
62 |
64 |
65 |
86 |
87 |
89 |
90 |
111 |
112 |
113 |
114 |
115 | Cron
10 || # | 14 |URL | 15 |Payload | 16 |Schedule | 17 |Next run | 18 |Response | 19 |
|---|---|---|---|---|---|
| {{ task.task_id }} | 26 |{{ task.url }} ({{ task.expected }}) | 27 |{{ task.payload }} | 28 |{{ task.schedule }} | 29 |{{ task.next_run }} | 30 |Tries #{{ task.tries }}: {{ task.last_error_body }} ({{ task.last_error_status_code }}) | 31 |
Dead
37 || # | 41 |URL | 42 |Payload | 43 |Next run | 44 |Response | 45 |
|---|---|---|---|---|
| {{ task.task_id }} | 52 |{{ task.url }} ({{ task.expected }}) | 53 |{{ task.payload }} | 54 |{{ task.next_run }} | 55 |Tries #{{ task.tries }}: {{ task.last_error_body }} ({{ task.last_error_status_code }}) | 56 |
Waiting
63 || # | 67 |URL | 68 |Payload | 69 |Next run | 70 |Response | 71 |
|---|---|---|---|---|
| {{ task.task_id }} | 78 |{{ task.url }} ({{ task.expected }}) | 79 |{{ task.payload }} | 80 |{{ task.next_run }} | 81 |Tries #{{ task.tries }}: {{ task.last_error_body }} ({{ task.last_error_status_code }}) | 82 |
Success
88 || # | 92 |URL | 93 |Payload | 94 |Next run | 95 |Response | 96 |
|---|---|---|---|---|
| {{ task.task_id }} | 103 |{{ task.url }} ({{ task.expected }}) | 104 |{{ task.payload }} | 105 |{{ task.next_run }} | 106 |Tries #{{ task.tries }}: {{ task.last_error_body }} ({{ task.last_error_status_code }}) | 107 |
19 |
20 |
21 | {% include "header.html" %}
22 |
23 |
24 | {% for item in pinned %}
25 | {% if item.meta.pinned %}
26 |
73 |
74 |
75 | {% endblock %}
76 | {% block links %}
77 |
78 |
79 |
80 | {{ utils.display_pagination_links(older_than, newer_than) }}{% endblock %}
81 |
--------------------------------------------------------------------------------
/core/feed.py:
--------------------------------------------------------------------------------
1 | from typing import Any
2 | from typing import Dict
3 | from typing import Optional
4 |
5 | from feedgen.feed import FeedGenerator
6 | from html2text import html2text
7 | from little_boxes import activitypub as ap
8 |
9 | from config import ID
10 | from config import ME
11 | from config import USERNAME
12 | from core.db import DB
13 | from core.meta import Box
14 |
15 |
16 | def gen_feed():
17 | fg = FeedGenerator()
18 | fg.id(f"{ID}")
19 | fg.title(f"{USERNAME} notes")
20 | fg.author({"name": USERNAME})
21 | fg.link(href=ID, rel="alternate")
22 | fg.description(f"{USERNAME} notes")
23 | fg.logo(ME.get("icon", {}).get("url"))
24 | fg.language("en")
25 | for item in DB.activities.find(
26 | {
27 | "box": Box.OUTBOX.value,
28 | "type": "Create",
29 | "meta.deleted": False,
30 | "meta.public": True,
31 | },
32 | limit=10,
33 | ).sort("_id", -1):
34 | fe = fg.add_entry()
35 | fe.id(item["activity"]["object"].get("url"))
36 | fe.link(href=item["activity"]["object"].get("url"))
37 | fe.title(item["activity"]["object"]["content"])
38 | fe.description(item["activity"]["object"]["content"])
39 | return fg
40 |
41 |
42 | def json_feed(path: str) -> Dict[str, Any]:
43 | """JSON Feed (https://jsonfeed.org/) document."""
44 | data = []
45 | for item in DB.activities.find(
46 | {
47 | "box": Box.OUTBOX.value,
48 | "type": "Create",
49 | "meta.deleted": False,
50 | "meta.public": True,
51 | },
52 | limit=10,
53 | ).sort("_id", -1):
54 | data.append(
55 | {
56 | "id": item["activity"]["id"],
57 | "url": item["activity"]["object"].get("url"),
58 | "content_html": item["activity"]["object"]["content"],
59 | "content_text": html2text(item["activity"]["object"]["content"]),
60 | "date_published": item["activity"]["object"].get("published"),
61 | }
62 | )
63 | return {
64 | "version": "https://jsonfeed.org/version/1",
65 | "user_comment": (
66 | "This is a microblog feed. You can add this to your feed reader using the following URL: "
67 | + ID
68 | + path
69 | ),
70 | "title": USERNAME,
71 | "home_page_url": ID,
72 | "feed_url": ID + path,
73 | "author": {
74 | "name": USERNAME,
75 | "url": ID,
76 | "avatar": ME.get("icon", {}).get("url"),
77 | },
78 | "items": data,
79 | }
80 |
81 |
82 | def build_inbox_json_feed(
83 | path: str, request_cursor: Optional[str] = None
84 | ) -> Dict[str, Any]:
85 | """Build a JSON feed from the inbox activities."""
86 | data = []
87 | cursor = None
88 |
89 | q: Dict[str, Any] = {
90 | "type": "Create",
91 | "meta.deleted": False,
92 | "box": Box.INBOX.value,
93 | }
94 | if request_cursor:
95 | q["_id"] = {"$lt": request_cursor}
96 |
97 | for item in DB.activities.find(q, limit=50).sort("_id", -1):
98 | actor = ap.get_backend().fetch_iri(item["activity"]["actor"])
99 | data.append(
100 | {
101 | "id": item["activity"]["id"],
102 | "url": item["activity"]["object"].get("url"),
103 | "content_html": item["activity"]["object"]["content"],
104 | "content_text": html2text(item["activity"]["object"]["content"]),
105 | "date_published": item["activity"]["object"].get("published"),
106 | "author": {
107 | "name": actor.get("name", actor.get("preferredUsername")),
108 | "url": actor.get("url"),
109 | "avatar": actor.get("icon", {}).get("url"),
110 | },
111 | }
112 | )
113 | cursor = str(item["_id"])
114 |
115 | resp = {
116 | "version": "https://jsonfeed.org/version/1",
117 | "title": f"{USERNAME}'s stream",
118 | "home_page_url": ID,
119 | "feed_url": ID + path,
120 | "items": data,
121 | }
122 | if cursor and len(data) == 50:
123 | resp["next_url"] = ID + path + "?cursor=" + cursor
124 |
125 | return resp
126 |
--------------------------------------------------------------------------------
/core/tasks.py:
--------------------------------------------------------------------------------
1 | import os
2 | from datetime import datetime
3 | from datetime import timezone
4 | from typing import Any
5 | from typing import Dict
6 | from typing import Set
7 |
8 | from little_boxes import activitypub as ap
9 | from poussetaches import PousseTaches
10 |
11 | from config import DISABLE_WEBMENTIONS
12 | from config import MEDIA_CACHE
13 | from utils import parse_datetime
14 |
15 | p = PousseTaches(
16 | os.getenv("MICROBLOGPUB_POUSSETACHES_HOST", "http://localhost:7991"),
17 | os.getenv("MICROBLOGPUB_INTERNAL_HOST", "http://localhost:5000"),
18 | )
19 |
20 |
21 | class Tasks:
22 | @staticmethod
23 | def cache_object(iri: str) -> None:
24 | p.push(iri, "/task/cache_object")
25 |
26 | @staticmethod
27 | def cache_actor(iri: str, also_cache_attachments: bool = True) -> None:
28 | p.push(
29 | {"iri": iri, "also_cache_attachments": also_cache_attachments},
30 | "/task/cache_actor",
31 | )
32 |
33 | @staticmethod
34 | def cache_actor_icon(icon_url: str, actor_iri: str) -> None:
35 | if MEDIA_CACHE.is_actor_icon_cached(icon_url):
36 | return None
37 |
38 | p.push({"icon_url": icon_url, "actor_iri": actor_iri}, "/task/cache_actor_icon")
39 |
40 | @staticmethod
41 | def cache_emoji(url: str, iri: str) -> None:
42 | if MEDIA_CACHE.is_emoji_cached(iri):
43 | return None
44 |
45 | p.push({"url": url, "iri": iri}, "/task/cache_emoji")
46 |
47 | @staticmethod
48 | def send_webmentions(activity: ap.Create, links: Set[str]) -> None:
49 | if DISABLE_WEBMENTIONS:
50 | return None
51 |
52 | for link in links:
53 | p.push(
54 | {
55 | "link": link,
56 | "note_url": activity.get_object().get_url(),
57 | "remote_id": activity.id,
58 | },
59 | "/task/send_webmention",
60 | )
61 |
62 | @staticmethod
63 | def cache_emojis(activity: ap.BaseActivity) -> None:
64 | for emoji in activity.get_emojis():
65 | try:
66 | Tasks.cache_emoji(emoji.get_icon_url(), emoji.id)
67 | except KeyError:
68 | # TODO(tsileo): log invalid emoji
69 | pass
70 |
71 | @staticmethod
72 | def post_to_remote_inbox(payload: str, recp: str) -> None:
73 | p.push({"payload": payload, "to": recp}, "/task/post_to_remote_inbox")
74 |
75 | @staticmethod
76 | def forward_activity(iri: str) -> None:
77 | p.push(iri, "/task/forward_activity")
78 |
79 | @staticmethod
80 | def fetch_og_meta(iri: str) -> None:
81 | p.push(iri, "/task/fetch_og_meta")
82 |
83 | @staticmethod
84 | def process_reply(iri: str) -> None:
85 | p.push(iri, "/task/process_reply")
86 |
87 | @staticmethod
88 | def process_new_activity(iri: str) -> None:
89 | p.push(iri, "/task/process_new_activity")
90 |
91 | @staticmethod
92 | def cache_attachments(iri: str) -> None:
93 | p.push(iri, "/task/cache_attachments")
94 |
95 | @staticmethod
96 | def cache_attachment(attachment: Dict[str, Any], iri: str) -> None:
97 | p.push({"iri": iri, "attachment": attachment}, "/task/cache_attachment")
98 |
99 | @staticmethod
100 | def finish_post_to_inbox(iri: str) -> None:
101 | p.push(iri, "/task/finish_post_to_inbox")
102 |
103 | @staticmethod
104 | def finish_post_to_outbox(iri: str) -> None:
105 | p.push(iri, "/task/finish_post_to_outbox")
106 |
107 | @staticmethod
108 | def send_actor_update() -> None:
109 | p.push({}, "/task/send_actor_update", delay=2)
110 |
111 | @staticmethod
112 | def update_question_outbox(iri: str, open_for: int) -> None:
113 | p.push(
114 | iri, "/task/update_question", delay=open_for
115 | ) # XXX: delay expects minutes
116 |
117 | @staticmethod
118 | def fetch_remote_question(question) -> None:
119 | now = datetime.now(timezone.utc)
120 | dt = parse_datetime(question.closed or question.endTime)
121 | minutes = int((dt - now).total_seconds() / 60)
122 |
123 | if minutes > 0:
124 | # Only push the task if the poll is not ended yet
125 | p.push(
126 | question.id, "/task/fetch_remote_question", delay=minutes
127 | ) # XXX: delay expects minutes
128 |
--------------------------------------------------------------------------------
/core/meta.py:
--------------------------------------------------------------------------------
1 | from datetime import datetime
2 | from enum import Enum
3 | from enum import unique
4 | from typing import Any
5 | from typing import Dict
6 | from typing import List
7 | from typing import Union
8 |
9 | from little_boxes import activitypub as ap
10 |
11 | _SubQuery = Dict[str, Any]
12 |
13 |
14 | @unique
15 | class Box(Enum):
16 | INBOX = "inbox"
17 | OUTBOX = "outbox"
18 | REPLIES = "replies"
19 |
20 |
21 | @unique
22 | class FollowStatus(Enum):
23 | WAITING = "waiting"
24 | ACCEPTED = "accepted"
25 | REJECTED = "rejected"
26 |
27 |
28 | @unique
29 | class MetaKey(Enum):
30 | NOTIFICATION = "notification"
31 | NOTIFICATION_UNREAD = "notification_unread"
32 | NOTIFICATION_FOLLOWS_BACK = "notification_follows_back"
33 | POLL_ANSWER = "poll_answer"
34 | POLL_ANSWER_TO = "poll_answer_to"
35 | STREAM = "stream"
36 | ACTOR_ID = "actor_id"
37 | ACTOR = "actor"
38 | ACTOR_HASH = "actor_hash"
39 | UNDO = "undo"
40 | PUBLISHED = "published"
41 | GC_KEEP = "gc_keep"
42 | OBJECT = "object"
43 | OBJECT_ID = "object_id"
44 | OBJECT_ACTOR = "object_actor"
45 | OBJECT_ACTOR_ID = "object_actor_id"
46 | OBJECT_ACTOR_HASH = "object_actor_hash"
47 | PUBLIC = "public"
48 |
49 | PINNED = "pinned"
50 | HASHTAGS = "hashtags"
51 | MENTIONS = "mentions"
52 |
53 | FOLLOW_STATUS = "follow_status"
54 |
55 | THREAD_ROOT_PARENT = "thread_root_parent"
56 |
57 | IN_REPLY_TO = "in_reply_to"
58 | IN_REPLY_TO_SELF = "in_reply_to_self"
59 | IN_REPLY_TO_ACTOR = "in_reply_to_actor"
60 |
61 | SERVER = "server"
62 | VISIBILITY = "visibility"
63 | OBJECT_VISIBILITY = "object_visibility"
64 |
65 | DELETED = "deleted"
66 | BOOSTED = "boosted"
67 | LIKED = "liked"
68 |
69 | COUNT_LIKE = "count_like"
70 | COUNT_BOOST = "count_boost"
71 | COUNT_REPLY = "count_reply"
72 |
73 | EMOJI_REACTIONS = "emoji_reactions"
74 |
75 |
76 | def _meta(mk: MetaKey) -> str:
77 | return f"meta.{mk.value}"
78 |
79 |
80 | def flag(mk: MetaKey, val: Any) -> _SubQuery:
81 | return {_meta(mk): val}
82 |
83 |
84 | def by_remote_id(remote_id: str) -> _SubQuery:
85 | return {"remote_id": remote_id}
86 |
87 |
88 | def in_inbox() -> _SubQuery:
89 | return {"box": Box.INBOX.value}
90 |
91 |
92 | def in_outbox() -> _SubQuery:
93 | return {"box": Box.OUTBOX.value}
94 |
95 |
96 | def by_type(type_: Union[ap.ActivityType, List[ap.ActivityType]]) -> _SubQuery:
97 | if isinstance(type_, list):
98 | return {"type": {"$in": [t.value for t in type_]}}
99 |
100 | return {"type": type_.value}
101 |
102 |
103 | def follow_request_accepted() -> _SubQuery:
104 | return flag(MetaKey.FOLLOW_STATUS, FollowStatus.ACCEPTED.value)
105 |
106 |
107 | def not_poll_answer() -> _SubQuery:
108 | return flag(MetaKey.POLL_ANSWER, False)
109 |
110 |
111 | def not_in_reply_to() -> _SubQuery:
112 | return {"activity.object.inReplyTo": None}
113 |
114 |
115 | def not_undo() -> _SubQuery:
116 | return flag(MetaKey.UNDO, False)
117 |
118 |
119 | def not_deleted() -> _SubQuery:
120 | return flag(MetaKey.DELETED, False)
121 |
122 |
123 | def pinned() -> _SubQuery:
124 | return flag(MetaKey.PINNED, True)
125 |
126 |
127 | def by_actor(actor: ap.BaseActivity) -> _SubQuery:
128 | return flag(MetaKey.ACTOR_ID, actor.id)
129 |
130 |
131 | def by_actor_id(actor_id: str) -> _SubQuery:
132 | return flag(MetaKey.ACTOR_ID, actor_id)
133 |
134 |
135 | def by_object_id(object_id: str) -> _SubQuery:
136 | return flag(MetaKey.OBJECT_ID, object_id)
137 |
138 |
139 | def is_public() -> _SubQuery:
140 | return flag(MetaKey.PUBLIC, True)
141 |
142 |
143 | def by_visibility(vis: ap.Visibility) -> _SubQuery:
144 | return flag(MetaKey.VISIBILITY, vis.name)
145 |
146 |
147 | def by_object_visibility(vis: ap.Visibility) -> _SubQuery:
148 | return flag(MetaKey.OBJECT_VISIBILITY, vis.name)
149 |
150 |
151 | def by_hashtag(ht: str) -> _SubQuery:
152 | return flag(MetaKey.HASHTAGS, ht)
153 |
154 |
155 | def inc(mk: MetaKey, val: int) -> _SubQuery:
156 | return {"$inc": flag(mk, val)}
157 |
158 |
159 | def upsert(data: Dict[MetaKey, Any]) -> _SubQuery:
160 | sq: Dict[str, Any] = {}
161 |
162 | for mk, val in data.items():
163 | sq[_meta(mk)] = val
164 |
165 | return {"$set": sq}
166 |
167 |
168 | def published_after(dt: datetime) -> _SubQuery:
169 | return flag(MetaKey.PUBLISHED, {"$gt": ap.format_datetime(dt)})
170 |
--------------------------------------------------------------------------------
/utils/opengraph.py:
--------------------------------------------------------------------------------
1 | import logging
2 | import mimetypes
3 | from typing import Any
4 | from typing import Dict
5 | from typing import Set
6 | from urllib.parse import urlparse
7 |
8 | import opengraph
9 | import requests
10 | from bs4 import BeautifulSoup
11 | from little_boxes import activitypub as ap
12 | from little_boxes.errors import NotAnActivityError
13 | from little_boxes.urlutils import check_url
14 | from little_boxes.urlutils import is_url_valid
15 |
16 | from .lookup import lookup
17 |
18 | logger = logging.getLogger(__name__)
19 |
20 |
21 | def links_from_note(note: Dict[str, Any]) -> Set[str]:
22 | note_host = urlparse(ap._get_id(note["id"]) or "").netloc
23 |
24 | links = set()
25 | if "content" in note:
26 | soup = BeautifulSoup(note["content"], "html5lib")
27 | for link in soup.find_all("a"):
28 | h = link.get("href")
29 | ph = urlparse(h)
30 | if (
31 | ph.scheme in {"http", "https"}
32 | and ph.netloc != note_host
33 | and is_url_valid(h)
34 | ):
35 | links.add(h)
36 |
37 | # FIXME(tsileo): support summary and name fields
38 |
39 | return links
40 |
41 |
42 | def fetch_og_metadata(user_agent, links):
43 | res = []
44 | for l in links:
45 | # Try to skip media early
46 | mimetype, _ = mimetypes.guess_type(l)
47 | if mimetype and mimetype.split("/")[0] in ["image", "video", "audio"]:
48 | logger.info(f"skipping media link {l}")
49 | continue
50 |
51 | check_url(l)
52 |
53 | # Remove any AP objects
54 | try:
55 | lookup(l)
56 | continue
57 | except NotAnActivityError:
58 | pass
59 | except Exception:
60 | logger.exception(f"skipping {l} because of issues during AP lookup")
61 | continue
62 |
63 | try:
64 | h = requests.head(
65 | l, headers={"User-Agent": user_agent}, timeout=3, allow_redirects=True
66 | )
67 | h.raise_for_status()
68 | except requests.HTTPError as http_err:
69 | logger.debug(
70 | f"failed to HEAD {l}, got a {http_err.response.status_code}: {http_err.response.text}"
71 | )
72 | continue
73 | except requests.RequestException as err:
74 | logger.debug(f"failed to HEAD {l}: {err!r}")
75 | continue
76 |
77 | if h.headers.get("content-type") and not h.headers.get(
78 | "content-type"
79 | ).startswith("text/html"):
80 | logger.debug(f"skipping {l} for bad content type")
81 | continue
82 |
83 | try:
84 | r = requests.get(
85 | l, headers={"User-Agent": user_agent}, timeout=5, allow_redirects=True
86 | )
87 | r.raise_for_status()
88 | except requests.HTTPError as http_err:
89 | logger.debug(
90 | f"failed to GET {l}, got a {http_err.response.status_code}: {http_err.response.text}"
91 | )
92 | continue
93 | except requests.RequestException as err:
94 | logger.debug(f"failed to GET {l}: {err!r}")
95 | continue
96 |
97 | # FIXME(tsileo): check mimetype via the URL too (like we do for images)
98 | if not r.headers.get("content-type") or not r.headers.get(
99 | "content-type"
100 | ).startswith("text/html"):
101 | continue
102 |
103 | r.encoding = "UTF-8"
104 | html = r.text
105 | try:
106 | data = dict(opengraph.OpenGraph(html=html))
107 | except Exception:
108 | logger.exception(f"failed to parse {l}")
109 | continue
110 |
111 | # Keep track of the fetched URL as some crappy websites use relative URLs everywhere
112 | data["_input_url"] = l
113 | u = urlparse(l)
114 |
115 | # If it's a relative URL, build the absolute version
116 | if "image" in data and data["image"].startswith("/"):
117 | data["image"] = u._replace(
118 | path=data["image"], params="", query="", fragment=""
119 | ).geturl()
120 |
121 | if "url" in data and data["url"].startswith("/"):
122 | data["url"] = u._replace(
123 | path=data["url"], params="", query="", fragment=""
124 | ).geturl()
125 |
126 | if data.get("url"):
127 | res.append(data)
128 |
129 | return res
130 |
--------------------------------------------------------------------------------
/docs/api.md:
--------------------------------------------------------------------------------
1 | ## API
2 |
3 | Your admin API key can be found at `config/admin_api_key.key`.
4 |
5 | ## ActivityPub API
6 |
7 | ### GET /
8 |
9 | Returns the actor profile, with links to all the "standard" collections.
10 |
11 | ### GET /tags/:tag
12 |
13 | Special collection that reference notes with the given tag.
14 |
15 | ### GET /stream
16 |
17 | Special collection that returns the stream/inbox as displayed in the UI.
18 |
19 | ## User API
20 |
21 | The user API is used by the admin UI (and requires a CSRF token when used with a regular user session), but it can also be accessed with an API key.
22 |
23 | All the examples are using [HTTPie](https://httpie.org/).
24 |
25 | ### POST /api/note/delete{?id}
26 |
27 | Deletes the given note `id` (the note must from the instance outbox).
28 |
29 | Answers a **201** (Created) status code.
30 |
31 | You can pass the `id` via JSON, form data or query argument.
32 |
33 | #### Example
34 |
35 | ```shell
36 | $ http POST https://microblog.pub/api/note/delete Authorization:'Bearer 27 | 28 |
29 | {% endif %} 30 | 31 | {{ utils.display_note(item.activity.object, meta=item.meta, no_color=True) }} 32 | {% endfor %} 33 | 34 | {% for item in outbox_data %} 35 | 36 | {% if item | has_type('Announce') %} 37 | {% if "actor" in item.meta %} 38 | {% set boost_actor = item.meta.actor %} 39 | {% if session.logged_in %} 40 |
41 |
47 | {{ utils.display_actor_box(boost_actor, after="boosted") }}
48 | {{ utils.display_in_reply_to(item.meta, item.activity.object) }}
49 |
50 | {% else %}
51 | 52 | {{ utils.display_actor_box(boost_actor, after="boosted") }} 53 | {{ utils.display_in_reply_to(item.meta, item.activity.object) }} 54 |
55 | {% endif %} 56 | {% endif %} 57 | {% if item.meta.object %} 58 | {{ utils.display_note(item.meta.object, meta=item.meta) }} 59 | {% endif %} 60 | {% elif item | has_type('Create') %} 61 | {% if item.activity.object.inReplyTo %} 62 |63 | {{ utils.display_in_reply_to(item.meta, item.activity.object) }} 64 |
65 | {% endif %} 66 | {{ utils.display_note(item.activity.object, meta=item.meta, no_color=True) }} 67 | {% endif %} 68 | 69 | {% endfor %} 70 | 71 | {{ utils.display_pagination(older_than, newer_than) }} 72 |
9 |
92 |
93 | {% endblock %}
139 |
--------------------------------------------------------------------------------
/core/outbox.py:
--------------------------------------------------------------------------------
1 | import logging
2 | from datetime import datetime
3 | from functools import singledispatch
4 | from typing import Any
5 | from typing import Dict
6 |
7 | from little_boxes import activitypub as ap
8 |
9 | from core.activitypub import handle_replies
10 | from core.db import find_one_activity
11 | from core.db import update_many_activities
12 | from core.db import update_one_activity
13 | from core.meta import MetaKey
14 | from core.meta import by_object_id
15 | from core.meta import by_type
16 | from core.meta import inc
17 | from core.meta import upsert
18 | from core.tasks import Tasks
19 |
20 | _logger = logging.getLogger(__name__)
21 |
22 | _NewMeta = Dict[str, Any]
23 |
24 |
25 | @singledispatch
26 | def process_outbox(activity: ap.BaseActivity, new_meta: _NewMeta) -> None:
27 | _logger.warning(f"skipping {activity!r}")
28 | return None
29 |
30 |
31 | @process_outbox.register
32 | def _delete_process_outbox(delete: ap.Delete, new_meta: _NewMeta) -> None:
33 | _logger.info(f"process_outbox activity={delete!r}")
34 | obj_id = delete.get_object_id()
35 |
36 | # Flag everything referencing the deleted object as deleted (except the Delete activity itself)
37 | update_many_activities(
38 | {**by_object_id(obj_id), "remote_id": {"$ne": delete.id}},
39 | upsert({MetaKey.DELETED: True, MetaKey.UNDO: True}),
40 | )
41 |
42 | # If the deleted activity was in DB, decrease some threads-related counter
43 | data = find_one_activity(
44 | {**by_object_id(obj_id), **by_type(ap.ActivityType.CREATE)}
45 | )
46 | _logger.info(f"found local copy of deleted activity: {data}")
47 | if data:
48 | obj = ap.parse_activity(data["activity"]).get_object()
49 | _logger.info(f"obj={obj!r}")
50 | in_reply_to = obj.get_in_reply_to()
51 | if in_reply_to:
52 | update_one_activity(
53 | {**by_type(ap.ActivityType.CREATE), **by_object_id(in_reply_to)},
54 | {"$inc": {"meta.count_reply": -1, "meta.count_direct_reply": -1}},
55 | )
56 |
57 |
58 | @process_outbox.register
59 | def _update_process_outbox(update: ap.Update, new_meta: _NewMeta) -> None:
60 | _logger.info(f"process_outbox activity={update!r}")
61 |
62 | obj = update._data["object"]
63 |
64 | update_prefix = "activity.object."
65 | to_update: Dict[str, Any] = {"$set": dict(), "$unset": dict()}
66 | to_update["$set"][f"{update_prefix}updated"] = (
67 | datetime.utcnow().replace(microsecond=0).isoformat() + "Z"
68 | )
69 | for k, v in obj.items():
70 | if k in ["id", "type"]:
71 | continue
72 | if v is None:
73 | to_update["$unset"][f"{update_prefix}{k}"] = ""
74 | else:
75 | to_update["$set"][f"{update_prefix}{k}"] = v
76 |
77 | if len(to_update["$unset"]) == 0:
78 | del to_update["$unset"]
79 |
80 | _logger.info(f"updating note from outbox {obj!r} {to_update}")
81 | update_one_activity({"activity.object.id": obj["id"]}, to_update)
82 | # FIXME(tsileo): should send an Update (but not a partial one, to all the note's recipients
83 | # (create a new Update with the result of the update, and send it without saving it?)
84 |
85 |
86 | @process_outbox.register
87 | def _create_process_outbox(create: ap.Create, new_meta: _NewMeta) -> None:
88 | _logger.info(f"process_outbox activity={create!r}")
89 | handle_replies(create)
90 |
91 |
92 | @process_outbox.register
93 | def _announce_process_outbox(announce: ap.Announce, new_meta: _NewMeta) -> None:
94 | _logger.info(f"process_outbox activity={announce!r}")
95 |
96 | obj = announce.get_object()
97 | if obj.has_type(ap.ActivityType.QUESTION):
98 | Tasks.fetch_remote_question(obj)
99 |
100 | Tasks.cache_object(announce.id)
101 |
102 | update_one_activity(
103 | {**by_object_id(obj.id), **by_type(ap.ActivityType.CREATE)},
104 | upsert({MetaKey.BOOSTED: announce.id}),
105 | )
106 |
107 |
108 | @process_outbox.register
109 | def _like_process_outbox(like: ap.Like, new_meta: _NewMeta) -> None:
110 | _logger.info(f"process_outbox activity={like!r}")
111 |
112 | obj = like.get_object()
113 | if obj.has_type(ap.ActivityType.QUESTION):
114 | Tasks.fetch_remote_question(obj)
115 |
116 | # Cache the object for display on the "Liked" public page
117 | Tasks.cache_object(like.id)
118 |
119 | update_one_activity(
120 | {**by_object_id(obj.id), **by_type(ap.ActivityType.CREATE)},
121 | {**inc(MetaKey.COUNT_LIKE, 1), **upsert({MetaKey.LIKED: like.id})},
122 | )
123 |
124 |
125 | @process_outbox.register
126 | def _undo_process_outbox(undo: ap.Undo, new_meta: _NewMeta) -> None:
127 | _logger.info(f"process_outbox activity={undo!r}")
128 | obj = undo.get_object()
129 | update_one_activity({"remote_id": obj.id}, {"$set": {"meta.undo": True}})
130 |
131 | # Undo Like
132 | if obj.has_type(ap.ActivityType.LIKE):
133 | liked = obj.get_object_id()
134 | update_one_activity(
135 | {**by_object_id(liked), **by_type(ap.ActivityType.CREATE)},
136 | {**inc(MetaKey.COUNT_LIKE, -1), **upsert({MetaKey.LIKED: False})},
137 | )
138 |
139 | elif obj.has_type(ap.ActivityType.ANNOUNCE):
140 | announced = obj.get_object_id()
141 | update_one_activity(
142 | {**by_object_id(announced), **by_type(ap.ActivityType.CREATE)},
143 | upsert({MetaKey.BOOSTED: False}),
144 | )
145 |
146 | # Undo Follow (undo new following)
147 | elif obj.has_type(ap.ActivityType.FOLLOW):
148 | pass
149 | # do nothing
150 |
--------------------------------------------------------------------------------
/config.py:
--------------------------------------------------------------------------------
1 | import mimetypes
2 | import os
3 | import subprocess
4 | from datetime import datetime
5 | from enum import Enum
6 | from pathlib import Path
7 |
8 | import yaml
9 | from bleach import linkify
10 | from itsdangerous import JSONWebSignatureSerializer
11 | from little_boxes import strtobool
12 | from little_boxes.activitypub import CTX_AS as AP_DEFAULT_CTX
13 | from pymongo import MongoClient
14 |
15 | import sass
16 | from utils.emojis import _load_emojis
17 | from utils.key import KEY_DIR
18 | from utils.key import get_key
19 | from utils.key import get_secret_key
20 | from utils.media import MediaCache
21 |
22 | ROOT_DIR = Path(__file__).parent.absolute()
23 |
24 |
25 | class ThemeStyle(Enum):
26 | LIGHT = "light"
27 | DARK = "dark"
28 |
29 |
30 | DEFAULT_THEME_STYLE = ThemeStyle.LIGHT.value
31 |
32 | DEFAULT_THEME_PRIMARY_COLOR = {
33 | ThemeStyle.LIGHT: "#1d781d", # Green
34 | ThemeStyle.DARK: "#33ff00", # Purple
35 | }
36 |
37 |
38 | VERSION = (
39 | subprocess.check_output(["git", "describe", "--always"]).split()[0].decode("utf-8")
40 | )
41 | VERSION_DATE = (
42 | subprocess.check_output(["git", "show", VERSION])
43 | .decode()
44 | .splitlines()[2]
45 | .split("Date:")[-1]
46 | .strip()
47 | )
48 |
49 | DEBUG_MODE = strtobool(os.getenv("MICROBLOGPUB_DEBUG", "false"))
50 |
51 | HEADERS = [
52 | "application/activity+json",
53 | "application/ld+json;profile=https://www.w3.org/ns/activitystreams",
54 | 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"',
55 | "application/ld+json",
56 | ]
57 |
58 |
59 | with open(os.path.join(KEY_DIR, "me.yml")) as f:
60 | conf = yaml.safe_load(f)
61 |
62 | USERNAME = conf["username"]
63 | NAME = conf["name"]
64 | DOMAIN = conf["domain"]
65 | SCHEME = "https" if conf.get("https", True) else "http"
66 | BASE_URL = SCHEME + "://" + DOMAIN
67 | ID = BASE_URL
68 | SUMMARY = conf["summary"]
69 | ICON_URL = conf["icon_url"]
70 | FAVICON_URL = conf.get("favicon_url", "/static/favicon.png")
71 | PASS = conf["pass"]
72 |
73 | PROFILE_METADATA = conf.get("profile_metadata", {})
74 | HIDE_FOLLOWING = conf.get("hide_following", True)
75 |
76 | ALIASES = conf.get('aliases', [])
77 |
78 | # Theme-related config
79 | theme_conf = conf.get("theme", {})
80 | THEME_STYLE = ThemeStyle(theme_conf.get("style", DEFAULT_THEME_STYLE))
81 | THEME_COLOR = theme_conf.get("color", DEFAULT_THEME_PRIMARY_COLOR[THEME_STYLE])
82 |
83 |
84 | DEFAULT_CTX = [
85 | AP_DEFAULT_CTX,
86 | f"{BASE_URL}/microblogpub-0.1.jsonld",
87 | {"@language": "und"},
88 | ]
89 |
90 | SASS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "sass")
91 | theme_css = f"$primary-color: {THEME_COLOR};\n"
92 | with open(os.path.join(SASS_DIR, f"{THEME_STYLE.value}.scss")) as f:
93 | theme_css += f.read()
94 | theme_css += "\n"
95 | with open(os.path.join(SASS_DIR, "base_theme.scss")) as f:
96 | raw_css = theme_css + f.read()
97 | CSS = sass.compile(string=raw_css, output_style="compressed")
98 |
99 |
100 | USER_AGENT = f"microblog.pub/{VERSION}; +{BASE_URL}"
101 |
102 | mongo_client = MongoClient(
103 | host=[os.getenv("MICROBLOGPUB_MONGODB_HOST", "localhost:27017")]
104 | )
105 |
106 | DB_NAME = "{}_{}".format(USERNAME, DOMAIN.replace(".", "_"))
107 | DB = mongo_client[DB_NAME]
108 | GRIDFS = mongo_client[f"{DB_NAME}_gridfs"]
109 | MEDIA_CACHE = MediaCache(GRIDFS, USER_AGENT)
110 |
111 |
112 | def _drop_db():
113 | if not DEBUG_MODE:
114 | return
115 |
116 | mongo_client.drop_database(DB_NAME)
117 |
118 |
119 | KEY = get_key(ID, ID + "#main-key", USERNAME, DOMAIN)
120 |
121 |
122 | JWT_SECRET = get_secret_key("jwt")
123 | JWT = JSONWebSignatureSerializer(JWT_SECRET)
124 |
125 |
126 | def _admin_jwt_token() -> str:
127 | return JWT.dumps( # type: ignore
128 | {"me": "ADMIN", "ts": datetime.now().timestamp()}
129 | ).decode( # type: ignore
130 | "utf-8"
131 | )
132 |
133 |
134 | ADMIN_API_KEY = get_secret_key("admin_api_key", _admin_jwt_token)
135 |
136 | attachments = []
137 | if PROFILE_METADATA:
138 | for key, value in PROFILE_METADATA.items():
139 | attachments.append(
140 | {"type": "PropertyValue", "name": key, "value": linkify(value)}
141 | )
142 |
143 | MANUALLY_APPROVES_FOLLOWERS = bool(conf.get("manually_approves_followers", False))
144 |
145 | ME = {
146 | "@context": DEFAULT_CTX,
147 | "type": "Person",
148 | "id": ID,
149 | "following": ID + "/following",
150 | "followers": ID + "/followers",
151 | "featured": ID + "/featured",
152 | "inbox": ID + "/inbox",
153 | "outbox": ID + "/outbox",
154 | "preferredUsername": USERNAME,
155 | "name": NAME,
156 | "summary": SUMMARY,
157 | "endpoints": {},
158 | "url": ID,
159 | "manuallyApprovesFollowers": MANUALLY_APPROVES_FOLLOWERS,
160 | "attachment": attachments,
161 | "icon": {
162 | "mediaType": mimetypes.guess_type(ICON_URL)[0],
163 | "type": "Image",
164 | "url": ICON_URL,
165 | },
166 | "publicKey": KEY.to_dict(),
167 | "alsoKnownAs": ALIASES,
168 | }
169 |
170 | # Default emojis, space-separated, update `me.yml` to customize emojis
171 | EMOJIS = "😺 😸 😹 😻 😼 😽 🙀 😿 😾"
172 | if conf.get("emojis"):
173 | EMOJIS = conf["emojis"]
174 |
175 | # Emoji template for the FE
176 | EMOJI_TPL = '
10 | {% if thread %}
11 |
89 |
90 |
91 | Replying to {{ content }}
12 | {{ utils.display_thread(thread) }} 13 | {% else %} 14 | 21 | {% endif %} 22 |
'
177 | if conf.get("emoji_tpl"):
178 | EMOJI_TPL = conf["emoji_tpl"]
179 |
180 | # Hosts blacklist
181 | BLACKLIST = conf.get("blacklist", [])
182 |
183 | # Outbound Webmentions support for public posts
184 | DISABLE_WEBMENTIONS = bool(conf.get("disable_webmentions", False))
185 |
186 | # Whether replies should be displayed in the stream or not
187 | REPLIES_IN_STREAM = bool(conf.get("replies_in_stream", False))
188 |
189 | # By default, we keep 14 of inbox data ; outbox is kept forever (along with bookmarked stuff, outbox replies, liked...)
190 | DAYS_TO_KEEP = int(conf.get("days_to_keep", 14))
191 |
192 | # Load custom emojis (stored in static/emojis)
193 | _load_emojis(ROOT_DIR, BASE_URL)
194 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # microblog.pub
2 |
3 |
4 | 
7 |
A self-hosted, single-user, ActivityPub powered microblog.
9 |
10 | 
11 | 
12 | 
13 | 
14 |
6 |
266 | {% endblock %}
267 |
--------------------------------------------------------------------------------
/utils/template_filters.py:
--------------------------------------------------------------------------------
1 | import logging
2 | import urllib
3 | from datetime import datetime
4 | from datetime import timezone
5 | from functools import lru_cache
6 | from urllib.parse import urlparse
7 |
8 | import bleach
9 | import emoji_unicode
10 | import flask
11 | import html2text
12 | import timeago
13 | from bs4 import BeautifulSoup
14 | from cachetools import LRUCache
15 | from little_boxes import activitypub as ap
16 | from little_boxes.activitypub import _to_list
17 | from little_boxes.errors import ActivityGoneError
18 | from little_boxes.errors import ActivityNotFoundError
19 |
20 | from config import BASE_URL
21 | from config import EMOJI_TPL
22 | from config import ID
23 | from config import MEDIA_CACHE
24 | from core.activitypub import _answer_key
25 | from utils import parse_datetime
26 | from utils.highlight import highlight
27 | from utils.media import Kind
28 | from utils.media import _is_img
29 |
30 | _logger = logging.getLogger(__name__)
31 |
32 | H2T = html2text.HTML2Text()
33 | H2T.ignore_links = True
34 | H2T.ignore_images = True
35 |
36 |
37 | filters = flask.Blueprint("filters", __name__)
38 |
39 |
40 | @filters.app_template_filter()
41 | def get_visibility(meta):
42 | if "object_visibility" in meta and meta["object_visibility"]:
43 | return meta["object_visibility"]
44 | return meta.get("visibility")
45 |
46 |
47 | @filters.app_template_filter()
48 | def visibility(v: str) -> str:
49 | try:
50 | return ap.Visibility[v].value.lower()
51 | except Exception:
52 | return v
53 |
54 |
55 | @filters.app_template_filter()
56 | def visibility_is_public(v: str) -> bool:
57 | return v in [ap.Visibility.PUBLIC.name, ap.Visibility.UNLISTED.name]
58 |
59 |
60 | @filters.app_template_filter()
61 | def code_highlight(content):
62 | return highlight(content)
63 |
64 |
65 | @filters.app_template_filter()
66 | def emojify(text):
67 | return emoji_unicode.replace(
68 | text, lambda e: EMOJI_TPL.format(filename=e.code_points, raw=e.unicode)
69 | )
70 |
71 |
72 | # HTML/templates helper
73 | ALLOWED_TAGS = [
74 | "a",
75 | "abbr",
76 | "acronym",
77 | "b",
78 | "br",
79 | "blockquote",
80 | "code",
81 | "pre",
82 | "em",
83 | "i",
84 | "li",
85 | "ol",
86 | "strong",
87 | "sup",
88 | "sub",
89 | "del",
90 | "ul",
91 | "span",
92 | "div",
93 | "p",
94 | "h1",
95 | "h2",
96 | "h3",
97 | "h4",
98 | "h5",
99 | "h6",
100 | "table",
101 | "th",
102 | "tr",
103 | "td",
104 | "thead",
105 | "tbody",
106 | "tfoot",
107 | "colgroup",
108 | "caption",
109 | "img",
110 | ]
111 |
112 | ALLOWED_ATTRIBUTES = {
113 | "a": ["href", "title"],
114 | "abbr": ["title"],
115 | "acronym": ["title"],
116 | "img": ["src", "alt", "title"],
117 | }
118 |
119 |
120 | @filters.app_template_filter()
121 | def replace_custom_emojis(content, note):
122 | idx = {}
123 | for tag in note.get("tag", []):
124 | if tag.get("type") == "Emoji":
125 | # try:
126 | idx[tag["name"]] = _get_file_url(tag["icon"]["url"], 25, Kind.EMOJI)
127 |
128 | for emoji_name, emoji_url in idx.items():
129 | content = content.replace(
130 | emoji_name,
131 | f'
7 |
8 | {% if list_name %}
9 |
264 |
265 | {{ list_name }}
10 | {% endif %} 11 | 12 | {% if request.path == url_for('admin.admin_notifications') and unread_notifications_count %} 13 |
14 |
20 |
21 | {% endif %}
22 |
23 | {% if actor %}
24 | {% set actor_redir = request.path + "?actor_id=" + request.args.get('actor_id') %}
25 |
26 |
27 | 
100 | {% else %}
101 |  }})
{% endif %}
102 |
103 |
126 |
127 | {% endif %}
128 |
129 |
28 | {% if follower %}{% endif %}
29 |
30 | {% if following %}
31 |
37 |
43 |
44 |
45 | {% if lists %}
46 |
60 | {% endif %}
61 |
62 | {% for l in lists %}
63 | {% if actor.id in l.members %}
64 |
70 |
71 |
72 | {% endif %}
73 | {% endfor %}
74 |
75 |
76 |
77 |
78 | {% else %}
79 |
85 |
91 |
92 |
93 | {% endif %}
94 |
95 |
96 |
97 |
98 | {% if not actor.icon %}
99 |
100 | {% else %}
101 |
104 |
108 |
109 |
110 | {% if actor.summary %}
111 | {{ (actor.name or actor.preferredUsername) | clean | replace_custom_emojis(actor) | safe }}
105 | @{{ actor.preferredUsername }}@{{ actor | url_or_id | get_url | domain }}
106 | {% if actor.manuallyApprovesFollowers %}Manually approves followers
{% endif %} 107 |
112 | {{ actor.summary | clean | replace_custom_emojis(actor) | safe }}
113 |
114 | {% endif %}
115 |
116 | {% if actor.attachment %}
117 | -
118 | {% for item in actor.attachment %}
119 | {% if item.type == "PropertyValue" %}
120 |
- {{ item.name }}: {{ item.value | clean | replace_custom_emojis(actor) | safe }} 121 | {% endif %} 122 | {% endfor %} 123 |
130 | {% for item in inbox_data %}
131 | {% if 'actor' in item.meta %}
132 | {% if item | has_type('Create') %}
133 |
263 |
134 | {% if request.path.startswith("/admin/notifications") and not item.meta.reply_acked and item.meta.object_visibility | visibility_is_public %}
135 |
141 |
142 | {% endif %}
143 | {{ utils.display_in_reply_to(item.meta, item.activity.object) }}
144 |
145 | {{ utils.display_note(item.activity.object, meta=item.meta) }}
146 | {% else %}
147 | {% if item | has_type('Announce') %}
148 | {% set boost_actor = item.meta.actor %}
149 | {% if boost_actor %}
150 |
151 | {{ utils.display_actor_box(boost_actor, after="boosted") }}
152 | {{ utils.display_in_reply_to(item.meta, item.activity.object) }}
153 |
154 | {% if request.path == url_for('admin.admin_notifications') %}
155 | {% if item.meta.notification_unread %}{% endif %}
156 |
157 | {% endif %}
158 |
159 |
160 | {% endif %}
161 | {% if item.meta.object %}
162 |
163 | {{ utils.display_note(item.meta.object, meta=item.meta) }}
164 | {% endif %}
165 | {% endif %}
166 |
167 | {% if item | has_type('Like') %}
168 | {% set boost_actor = item.meta.actor %}
169 |
170 | {{ utils.display_actor_box(boost_actor, after="liked") }}
171 | {{ utils.display_in_reply_to(item.meta, item.activity.object) }}
172 | {% if item.meta.notification_unread %}{% endif %}
173 |
174 |
175 | {% if item.meta.object %}
176 | {{ utils.display_note(item.meta.object, meta=item.meta) }}
177 | {% endif %}
178 | {% endif %}
179 |
180 | {% if item | has_type('Follow') %}
181 |
182 |
183 |
184 | {% if config.MANUALLY_APPROVES_FOLLOWERS and item.meta.follow_status != "accepted" %}
185 |
191 | {% endif %}
192 | {% if item.meta.notification_unread %}{% endif %}
193 |
194 | profile
195 | {% if item.meta.notification_follows_back %}
196 | {% else %}
197 |
203 | {% endif %}
204 |
205 |
206 | {{ utils.display_actor_inline(item.meta.actor, size=50) }}
207 |
208 |
209 | {% elif item | has_type('Accept') %}
210 |
211 |
212 | {% if item.meta.notification_unread %}{% endif %}
213 |
214 | profile
215 | {% if item.meta.notification_follows_back %}{% endif %}
216 |
217 |
218 |
219 | {{ utils.display_actor_inline(item.meta.actor, size=50) }}
220 |
221 |
222 | {% elif item | has_type('Reject') %}
223 |
224 |
225 | {% if item.meta.notification_unread %}{% endif %}
226 |
227 | profile
228 | {% if item.meta.notification_follows_back %}{% endif %}
229 |
230 |
231 |
232 | {{ utils.display_actor_inline(item.meta.actor, size=50) }}
233 |
234 |
235 | {% elif item | has_type('Undo') %}
236 |
237 |
238 | {% if item.meta.notification_unread %}{% endif %}
239 |
240 |
241 |
242 | {{ utils.display_actor_inline(item.meta.actor, size=50) }}
243 |
244 |
245 | {% else %}
246 |
247 | {% endif %}
248 |
249 |
250 | {% endif %}
251 | {% else %}
252 |
253 | {% if item | has_type('question_ended') %}
254 | 255 | {{ utils.display_note(item.activity, meta={"object_visibility": "PUBLIC"}) }} 256 | {% endif %} 257 | 258 | {% endif %} 259 | {% endfor %} 260 | 261 | {{ utils.display_pagination(older_than, newer_than) }} 262 |