diff --git a/social/templates/activity/review_item.html b/social/templates/activity/review_item.html
index 277d0a83..3092cd71 100644
--- a/social/templates/activity/review_item.html
+++ b/social/templates/activity/review_item.html
@@ -33,7 +33,7 @@
{% endif %}
diff --git a/social/tests.py b/social/tests.py
index 3d6093f2..b881977e 100644
--- a/social/tests.py
+++ b/social/tests.py
@@ -2,65 +2,86 @@ from django.test import TestCase
from catalog.models import *
from journal.models import *
+from takahe.utils import Takahe
from users.models import User
from .models import *
class SocialTest(TestCase):
+ databases = "__all__"
+
def setUp(self):
self.book1 = Edition.objects.create(title="Hyperion")
self.book2 = Edition.objects.create(title="Andymion")
self.movie = Edition.objects.create(title="Fight Club")
- self.alice = User.register(mastodon_site="MySpace", mastodon_username="Alice")
- self.bob = User.register(mastodon_site="KKCity", mastodon_username="Bob")
+ self.alice = User.register(
+ username="Alice", mastodon_site="MySpace", mastodon_username="Alice"
+ )
+ self.bob = User.register(
+ username="Bob", mastodon_site="KKCity", mastodon_username="Bob"
+ )
def test_timeline(self):
+ alice_feed = self.alice.identity.activity_manager
+ bob_feed = self.bob.identity.activity_manager
+
# alice see 0 activity in timeline in the beginning
- timeline = self.alice.activity_manager.get_timeline()
- self.assertEqual(len(timeline), 0)
+ self.assertEqual(len(alice_feed.get_timeline()), 0)
# 1 activity after adding first book to shelf
- self.alice.shelf_manager.move_item(self.book1, ShelfType.WISHLIST, visibility=1)
- timeline = self.alice.activity_manager.get_timeline()
- self.assertEqual(len(timeline), 1)
+ self.alice.identity.shelf_manager.move_item(
+ self.book1, ShelfType.WISHLIST, visibility=1
+ )
+ self.assertEqual(len(alice_feed.get_timeline()), 1)
# 2 activities after adding second book to shelf
- self.alice.shelf_manager.move_item(self.book2, ShelfType.WISHLIST)
- timeline = self.alice.activity_manager.get_timeline()
- self.assertEqual(len(timeline), 2)
+ self.alice.identity.shelf_manager.move_item(self.book2, ShelfType.WISHLIST)
+ self.assertEqual(len(alice_feed.get_timeline()), 2)
# 2 activities after change first mark
- self.alice.shelf_manager.move_item(self.book1, ShelfType.PROGRESS)
- timeline = self.alice.activity_manager.get_timeline()
- self.assertEqual(len(timeline), 2)
+ self.alice.identity.shelf_manager.move_item(self.book1, ShelfType.PROGRESS)
+ self.assertEqual(len(alice_feed.get_timeline()), 2)
# bob see 0 activity in timeline in the beginning
- timeline2 = self.bob.activity_manager.get_timeline()
- self.assertEqual(len(timeline2), 0)
+ self.assertEqual(len(bob_feed.get_timeline()), 0)
# bob follows alice, see 2 activities
- self.bob.mastodon_following = ["Alice@MySpace"]
- self.alice.mastodon_follower = ["Bob@KKCity"]
- self.bob.merge_relationships()
- timeline2 = self.bob.activity_manager.get_timeline()
- self.assertEqual(len(timeline2), 2)
+ self.bob.identity.follow(self.alice.identity)
+ Takahe._force_state_cycle()
+ self.assertEqual(len(bob_feed.get_timeline()), 2)
+
+ # bob mute, then unmute alice
+ self.bob.identity.mute(self.alice.identity)
+ Takahe._force_state_cycle()
+ self.assertEqual(len(bob_feed.get_timeline()), 0)
+ self.bob.identity.unmute(self.alice.identity)
+ Takahe._force_state_cycle()
+ self.assertEqual(len(bob_feed.get_timeline()), 2)
# alice:3 bob:2 after alice adding second book to shelf as private
- self.alice.shelf_manager.move_item(self.movie, ShelfType.WISHLIST, visibility=2)
- timeline = self.alice.activity_manager.get_timeline()
- self.assertEqual(len(timeline), 3)
- timeline2 = self.bob.activity_manager.get_timeline()
- self.assertEqual(len(timeline2), 2)
+ self.alice.identity.shelf_manager.move_item(
+ self.movie, ShelfType.WISHLIST, visibility=2
+ )
+ self.assertEqual(len(alice_feed.get_timeline()), 3)
+ self.assertEqual(len(bob_feed.get_timeline()), 2)
- # remote unfollow
- self.bob.mastodon_following = []
- self.alice.mastodon_follower = []
- self.bob.merge_relationships()
- timeline = self.bob.activity_manager.get_timeline()
- self.assertEqual(len(timeline), 0)
+ # alice mute bob
+ self.alice.identity.mute(self.bob.identity)
+ Takahe._force_state_cycle()
+ self.assertEqual(len(bob_feed.get_timeline()), 2)
- # local follow
- self.bob.follow(self.alice)
- timeline = self.bob.activity_manager.get_timeline()
- self.assertEqual(len(timeline), 2)
+ # bob unfollow alice
+ self.bob.identity.unfollow(self.alice.identity)
+ Takahe._force_state_cycle()
+ self.assertEqual(len(bob_feed.get_timeline()), 0)
+
+ # bob follow alice
+ self.bob.identity.follow(self.alice.identity)
+ Takahe._force_state_cycle()
+ self.assertEqual(len(bob_feed.get_timeline()), 2)
+
+ # alice block bob
+ self.alice.identity.block(self.bob.identity)
+ Takahe._force_state_cycle()
+ self.assertEqual(len(bob_feed.get_timeline()), 0)
diff --git a/social/views.py b/social/views.py
index 9a68b775..757cb2f4 100644
--- a/social/views.py
+++ b/social/views.py
@@ -1,7 +1,6 @@
import logging
-from django.conf import settings
-from django.contrib.auth.decorators import login_required, permission_required
+from django.contrib.auth.decorators import login_required
from django.core.exceptions import BadRequest
from django.shortcuts import render
from django.utils.translation import gettext_lazy as _
@@ -65,7 +64,7 @@ def data(request):
request,
"feed_data.html",
{
- "activities": ActivityManager(request.user).get_timeline(
+ "activities": ActivityManager(request.user.identity).get_timeline(
before_time=request.GET.get("last")
)[:PAGE_SIZE],
},
diff --git a/takahe/__init__.py b/takahe/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/takahe/admin.py b/takahe/admin.py
new file mode 100644
index 00000000..8c38f3f3
--- /dev/null
+++ b/takahe/admin.py
@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.
diff --git a/takahe/ap_handlers.py b/takahe/ap_handlers.py
new file mode 100644
index 00000000..b4d0ee6a
--- /dev/null
+++ b/takahe/ap_handlers.py
@@ -0,0 +1,123 @@
+from datetime import datetime
+
+from loguru import logger
+
+from catalog.common import *
+from journal.models import Comment, Piece, Rating, Review, ShelfMember
+from users.models import User as NeoUser
+
+from .models import Follow, Identity, Post
+from .utils import Takahe
+
+_supported_ap_catalog_item_types = [
+ "Edition",
+ "Movie",
+ "TVShow",
+ "TVSeason",
+ "TVEpisode",
+ "Album",
+ "Game",
+ "Podcast",
+ "Performance",
+ "PerformanceProduction",
+]
+
+_supported_ap_journal_types = {
+ "Status": ShelfMember,
+ "Rating": Rating,
+ "Comment": Comment,
+ "Review": Review,
+}
+
+
+def _parse_links(objects):
+ logger.debug(f"Parsing links from {objects}")
+ items = []
+ pieces = []
+ for obj in objects:
+ if obj["type"] in _supported_ap_catalog_item_types:
+ items.append(obj["url"])
+ elif obj["type"] in _supported_ap_journal_types.keys():
+ pieces.append(obj)
+ else:
+ logger.warning(f'Unknown link type {obj["type"]}')
+ return items, pieces
+
+
+def _get_or_create_item_by_ap_url(url):
+ logger.debug(f"Fetching item by ap from {url}")
+ site = SiteManager.get_site_by_url(url)
+ if not site:
+ return None
+ site.get_resource_ready()
+ item = site.get_item()
+ return item
+
+
+def _get_visibility(post_visibility):
+ match post_visibility:
+ case 2:
+ return 1
+ case 3:
+ return 2
+ case _:
+ return 0
+
+
+def _update_or_create_post(pk, obj):
+ post = Post.objects.get(pk=pk)
+ owner = Takahe.get_or_create_apidentity(post.author)
+ if not post.type_data:
+ logger.warning(f"Post {post} has no type_data")
+ return
+ items, pieces = _parse_links(post.type_data["object"]["relatedWith"])
+ logger.info(f"Post {post} has items {items} and pieces {pieces}")
+ if len(items) == 0:
+ logger.warning(f"Post {post} has no remote items")
+ return
+ elif len(items) > 1:
+ logger.warning(f"Post {post} has more than one remote item")
+ return
+ remote_url = items[0]
+ item = _get_or_create_item_by_ap_url(remote_url)
+ if not item:
+ logger.warning(f"Post {post} has no local item")
+ return
+ for p in pieces:
+ cls = _supported_ap_journal_types[p["type"]]
+ cls.update_by_ap_object(owner, item, p, pk, _get_visibility(post.visibility))
+
+
+def post_created(pk, obj):
+ _update_or_create_post(pk, obj)
+
+
+def post_updated(pk, obj):
+ _update_or_create_post(pk, obj)
+
+
+def post_deleted(pk, obj):
+ Piece.objects.filter(post_id=pk, local=False).delete()
+
+
+def user_follow_updated(source_identity_pk, target_identity_pk):
+ u = Takahe.get_local_user_by_identity(source_identity_pk)
+ # Takahe.update_user_following(u)
+ logger.info(f"User {u} following updated")
+
+
+def user_mute_updated(source_identity_pk, target_identity_pk):
+ u = Takahe.get_local_user_by_identity(source_identity_pk)
+ # Takahe.update_user_muting(u)
+ logger.info(f"User {u} muting updated")
+
+
+def user_block_updated(source_identity_pk, target_identity_pk):
+ u = Takahe.get_local_user_by_identity(source_identity_pk)
+ if u:
+ # Takahe.update_user_rejecting(u)
+ logger.info(f"User {u} rejecting updated")
+ u = Takahe.get_local_user_by_identity(target_identity_pk)
+ if u:
+ # Takahe.update_user_rejecting(u)
+ logger.info(f"User {u} rejecting updated")
diff --git a/takahe/apps.py b/takahe/apps.py
new file mode 100644
index 00000000..7d39fe99
--- /dev/null
+++ b/takahe/apps.py
@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class TakaheConfig(AppConfig):
+ default_auto_field = "django.db.models.BigAutoField"
+ name = "takahe"
diff --git a/takahe/db_routes.py b/takahe/db_routes.py
new file mode 100644
index 00000000..09015105
--- /dev/null
+++ b/takahe/db_routes.py
@@ -0,0 +1,27 @@
+from django.conf import settings
+
+_is_testing = "testserver" in settings.ALLOWED_HOSTS
+
+
+class TakaheRouter:
+ def db_for_read(self, model, **hints):
+ if model._meta.app_label == "takahe":
+ return "takahe"
+ return None
+
+ def db_for_write(self, model, **hints):
+ if model._meta.app_label == "takahe":
+ return "takahe"
+ return None
+
+ def allow_relation(self, obj1, obj2, **hints):
+ # skip this check but please make sure
+ # not create relations between takahe models and other apps
+ if obj1._meta.app_label == "takahe" or obj2._meta.app_label == "takahe":
+ return obj1._meta.app_label == obj2._meta.app_label
+ return None
+
+ def allow_migrate(self, db, app_label, model_name=None, **hints):
+ if app_label == "takahe" or db == "takahe":
+ return _is_testing and app_label == db
+ return None
diff --git a/takahe/html.py b/takahe/html.py
new file mode 100644
index 00000000..c598be2f
--- /dev/null
+++ b/takahe/html.py
@@ -0,0 +1,379 @@
+import html
+import re
+from html.parser import HTMLParser
+
+from django.utils.safestring import mark_safe
+
+
+class FediverseHtmlParser(HTMLParser):
+ """
+ A custom HTML parser that only allows a certain tag subset and behaviour:
+ - br, p tags are passed through
+ - a tags are passed through if they're not hashtags or mentions
+ - Another set of tags are converted to p
+
+ It also linkifies URLs, mentions, hashtags, and imagifies emoji.
+ """
+
+ REWRITE_TO_P = [
+ "p",
+ "h1",
+ "h2",
+ "h3",
+ "h4",
+ "h5",
+ "h6",
+ "blockquote",
+ "pre",
+ "ul",
+ "ol",
+ ]
+
+ REWRITE_TO_BR = [
+ "br",
+ "li",
+ ]
+
+ MENTION_REGEX = re.compile(
+ r"(^|[^\w\d\-_/])@([\w\d\-_]+(?:@[\w\d\-_\.]+[\w\d\-_]+)?)"
+ )
+
+ HASHTAG_REGEX = re.compile(r"\B#([a-zA-Z0-9(_)]+\b)(?!;)")
+
+ EMOJI_REGEX = re.compile(r"\B:([a-zA-Z0-9(_)-]+):\B")
+
+ URL_REGEX = re.compile(
+ r"""(\(* # Match any opening parentheses.
+ \b(?"]*)?)
+ # /path/zz (excluding "unsafe" chars from RFC 1738,
+ # except for # and ~, which happen in practice)
+ """,
+ re.IGNORECASE | re.VERBOSE | re.UNICODE,
+ )
+
+ def __init__(
+ self,
+ html: str,
+ uri_domain: str | None = None,
+ mentions: list | None = None,
+ find_mentions: bool = False,
+ find_hashtags: bool = False,
+ find_emojis: bool = False,
+ emoji_domain=None,
+ ):
+ super().__init__()
+ self.uri_domain = uri_domain
+ self.emoji_domain = emoji_domain
+ self.find_mentions = find_mentions
+ self.find_hashtags = find_hashtags
+ self.find_emojis = find_emojis
+ self.calculate_mentions(mentions)
+ self._data_buffer = ""
+ self.html_output = ""
+ self.text_output = ""
+ self.emojis: set[str] = set()
+ self.mentions: set[str] = set()
+ self.hashtags: set[str] = set()
+ self._pending_a: dict | None = None
+ self._fresh_p = False
+ self.feed(html.replace("\n", ""))
+ self.flush_data()
+
+ def calculate_mentions(self, mentions: list | None):
+ """
+ Prepares a set of content that we expect to see mentions look like
+ (this imp)
+ """
+ self.mention_matches: dict[str, str] = {}
+ self.mention_aliases: dict[str, str] = {}
+ for mention in mentions or []:
+ if self.uri_domain:
+ url = mention.absolute_profile_uri()
+ else:
+ url = str(mention.urls.view)
+ if mention.username:
+ username = mention.username.lower()
+ domain = mention.domain_id.lower()
+ self.mention_matches[f"{username}"] = url
+ self.mention_matches[f"{username}@{domain}"] = url
+ self.mention_matches[mention.absolute_profile_uri()] = url
+
+ def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+ if tag in self.REWRITE_TO_P:
+ self.flush_data()
+ self.html_output += "
"
+ elif tag in self.REWRITE_TO_BR:
+ self.flush_data()
+ if not self._fresh_p:
+ self.html_output += "
"
+ self.text_output += "\n"
+ elif tag == "a":
+ self.flush_data()
+ self._pending_a = {"attrs": dict(attrs), "content": ""}
+ self._fresh_p = tag in self.REWRITE_TO_P
+
+ def handle_endtag(self, tag: str) -> None:
+ self._fresh_p = False
+ if tag in self.REWRITE_TO_P:
+ self.flush_data()
+ self.html_output += "
"
+ self.text_output += "\n\n"
+ elif tag == "a":
+ if self._pending_a:
+ href = self._pending_a["attrs"].get("href")
+ content = self._pending_a["content"].strip()
+ has_ellipsis = "ellipsis" in self._pending_a["attrs"].get("class", "")
+ # Is it a mention?
+ if content.lower().lstrip("@") in self.mention_matches:
+ self.html_output += self.create_mention(content, href)
+ self.text_output += content
+ # Is it a hashtag?
+ elif self.HASHTAG_REGEX.match(content):
+ self.html_output += self.create_hashtag(content)
+ self.text_output += content
+ elif content:
+ # Shorten the link if we need to
+ self.html_output += self.create_link(
+ href,
+ content,
+ has_ellipsis=has_ellipsis,
+ )
+ self.text_output += href
+ self._pending_a = None
+
+ def handle_data(self, data: str) -> None:
+ self._fresh_p = False
+ if self._pending_a:
+ self._pending_a["content"] += data
+ else:
+ self._data_buffer += data
+
+ def flush_data(self) -> None:
+ """
+ We collect data segments until we encounter a tag we care about,
+ so we can treat
#hashtag as #hashtag
+ """
+ self.text_output += self._data_buffer
+ self.html_output += self.linkify(self._data_buffer)
+ self._data_buffer = ""
+
+ def create_link(self, href, content, has_ellipsis=False):
+ """
+ Generates a link, doing optional shortening.
+
+ All return values from this function should be HTML-safe.
+ """
+ looks_like_link = bool(self.URL_REGEX.match(content))
+ if looks_like_link:
+ protocol, content = content.split("://", 1)
+ else:
+ protocol = ""
+ if (looks_like_link and len(content) > 30) or has_ellipsis:
+ return f'
{html.escape(protocol)}://{html.escape(content[:30])}{html.escape(content[30:])}'
+ elif looks_like_link:
+ return f'
{html.escape(protocol)}://{html.escape(content)}'
+ else:
+ return f'
{html.escape(content)}'
+
+ def create_mention(self, handle, href: str | None = None) -> str:
+ """
+ Generates a mention link. Handle should have a leading @.
+
+ All return values from this function should be HTML-safe
+ """
+ handle = handle.lstrip("@")
+ if "@" in handle:
+ short_handle = handle.split("@", 1)[0]
+ else:
+ short_handle = handle
+ handle_hash = handle.lower()
+ short_hash = short_handle.lower()
+ self.mentions.add(handle_hash)
+ url = self.mention_matches.get(handle_hash)
+ # If we have a captured link out, use that as the actual resolver
+ if href and href in self.mention_matches:
+ url = self.mention_matches[href]
+ if url:
+ if short_hash not in self.mention_aliases:
+ self.mention_aliases[short_hash] = handle_hash
+ elif self.mention_aliases.get(short_hash) != handle_hash:
+ short_handle = handle
+ return f'
@{html.escape(short_handle)}'
+ else:
+ return "@" + html.escape(handle)
+
+ def create_hashtag(self, hashtag) -> str:
+ """
+ Generates a hashtag link. Hashtag does not need to start with #
+
+ All return values from this function should be HTML-safe
+ """
+ hashtag = hashtag.lstrip("#")
+ self.hashtags.add(hashtag.lower())
+ if self.uri_domain:
+ return f'
#{hashtag}'
+ else:
+ return f'
#{hashtag}'
+
+ def create_emoji(self, shortcode) -> str:
+ """
+ Generates an emoji
![]()
tag
+
+ All return values from this function should be HTML-safe
+ """
+ from .models import Emoji
+
+ emoji = Emoji.get_by_domain(shortcode, self.emoji_domain)
+ if emoji and emoji.is_usable:
+ self.emojis.add(shortcode)
+ return emoji.as_html()
+ return f":{shortcode}:"
+
+ def linkify(self, data):
+ """
+ Linkifies some content that is plaintext.
+
+ Handles URLs first, then mentions. Note that this takes great care to
+ keep track of what is HTML and what needs to be escaped.
+ """
+ # Split the string by the URL regex so we know what to escape and what
+ # not to escape.
+ bits = self.URL_REGEX.split(data)
+ result = ""
+ # Even indices are data we should pass though, odd indices are links
+ for i, bit in enumerate(bits):
+ # A link!
+ if i % 2 == 1:
+ result += self.create_link(bit, bit)
+ # Not a link
+ elif self.mention_matches or self.find_mentions:
+ result += self.linkify_mentions(bit)
+ elif self.find_hashtags:
+ result += self.linkify_hashtags(bit)
+ elif self.find_emojis:
+ result += self.linkify_emoji(bit)
+ else:
+ result += html.escape(bit)
+ return result
+
+ def linkify_mentions(self, data):
+ """
+ Linkifies mentions
+ """
+ bits = self.MENTION_REGEX.split(data)
+ result = ""
+ for i, bit in enumerate(bits):
+ # Mention content
+ if i % 3 == 2:
+ result += self.create_mention(bit)
+ # Not part of a mention (0) or mention preamble (1)
+ elif self.find_hashtags:
+ result += self.linkify_hashtags(bit)
+ elif self.find_emojis:
+ result += self.linkify_emoji(bit)
+ else:
+ result += html.escape(bit)
+ return result
+
+ def linkify_hashtags(self, data):
+ """
+ Linkifies hashtags
+ """
+ bits = self.HASHTAG_REGEX.split(data)
+ result = ""
+ for i, bit in enumerate(bits):
+ # Not part of a hashtag
+ if i % 2 == 0:
+ if self.find_emojis:
+ result += self.linkify_emoji(bit)
+ else:
+ result += html.escape(bit)
+ # Hashtag content
+ else:
+ result += self.create_hashtag(bit)
+ return result
+
+ def linkify_emoji(self, data):
+ """
+ Linkifies emoji
+ """
+ bits = self.EMOJI_REGEX.split(data)
+ result = ""
+ for i, bit in enumerate(bits):
+ # Not part of an emoji
+ if i % 2 == 0:
+ result += html.escape(bit)
+ # Emoji content
+ else:
+ result += self.create_emoji(bit)
+ return result
+
+ @property
+ def html(self):
+ return self.html_output.strip()
+
+ @property
+ def plain_text(self):
+ return self.text_output.strip()
+
+
+class ContentRenderer:
+ """
+ Renders HTML for posts, identity fields, and more.
+
+ The `local` parameter affects whether links are absolute (False) or relative (True)
+ """
+
+ def __init__(self, local: bool):
+ self.local = local
+
+ def render_post(self, html: str, post) -> str:
+ """
+ Given post HTML, normalises it and renders it for presentation.
+ """
+ if not html:
+ return ""
+ parser = FediverseHtmlParser(
+ html,
+ mentions=post.mentions.all(),
+ uri_domain=(None if self.local else post.author.domain.uri_domain),
+ find_hashtags=True,
+ find_emojis=self.local,
+ emoji_domain=post.author.domain,
+ )
+ return mark_safe(parser.html)
+
+ def render_identity_summary(self, html: str, identity) -> str:
+ """
+ Given identity summary HTML, normalises it and renders it for presentation.
+ """
+ if not html:
+ return ""
+ parser = FediverseHtmlParser(
+ html,
+ uri_domain=(None if self.local else identity.domain.uri_domain),
+ find_hashtags=True,
+ find_emojis=self.local,
+ emoji_domain=identity.domain,
+ )
+ return mark_safe(parser.html)
+
+ def render_identity_data(self, html: str, identity, strip: bool = False) -> str:
+ """
+ Given name/basic value HTML, normalises it and renders it for presentation.
+ """
+ if not html:
+ return ""
+ parser = FediverseHtmlParser(
+ html,
+ uri_domain=(None if self.local else identity.domain.uri_domain),
+ find_hashtags=False,
+ find_emojis=self.local,
+ emoji_domain=identity.domain,
+ )
+ if strip:
+ return mark_safe(parser.html)
+ else:
+ return mark_safe(parser.html)
diff --git a/takahe/management/commands/takahe.py b/takahe/management/commands/takahe.py
new file mode 100644
index 00000000..fc555a28
--- /dev/null
+++ b/takahe/management/commands/takahe.py
@@ -0,0 +1,42 @@
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.db.models import Count, F
+from loguru import logger
+from tqdm import tqdm
+
+from catalog.common import *
+from catalog.common.models import *
+from catalog.models import *
+from journal.models import Tag, update_journal_for_merged_item
+from takahe.utils import *
+from users.models import User as NeoUser
+
+
+class Command(BaseCommand):
+ def add_arguments(self, parser):
+ parser.add_argument(
+ "--verbose",
+ action="store_true",
+ )
+ parser.add_argument(
+ "--sync",
+ action="store_true",
+ )
+
+ def sync(self):
+ logger.info(f"Syncing domain...")
+ Takahe.get_domain()
+ logger.info(f"Syncing users...")
+ for u in tqdm(NeoUser.objects.filter(is_active=True, username__isnull=False)):
+ Takahe.init_identity_for_local_user(u)
+ # Takahe.update_user_following(u)
+ # Takahe.update_user_muting(u)
+ # Takahe.update_user_rejecting(u)
+
+ def handle(self, *args, **options):
+ self.verbose = options["verbose"]
+
+ if options["sync"]:
+ self.sync()
+
+ self.stdout.write(self.style.SUCCESS(f"Done."))
diff --git a/takahe/migrations/0001_initial.py b/takahe/migrations/0001_initial.py
new file mode 100644
index 00000000..66193237
--- /dev/null
+++ b/takahe/migrations/0001_initial.py
@@ -0,0 +1,489 @@
+# Generated by Django 4.2.4 on 2023-08-12 16:48
+
+import django.db.models.deletion
+import django.utils.timezone
+from django.db import migrations, models
+
+import takahe.models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="Domain",
+ fields=[
+ (
+ "domain",
+ models.CharField(max_length=250, primary_key=True, serialize=False),
+ ),
+ (
+ "service_domain",
+ models.CharField(
+ blank=True,
+ db_index=True,
+ max_length=250,
+ null=True,
+ unique=True,
+ ),
+ ),
+ ("state", models.CharField(default="outdated", max_length=100)),
+ ("state_changed", models.DateTimeField(auto_now_add=True)),
+ ("nodeinfo", models.JSONField(blank=True, null=True)),
+ ("local", models.BooleanField()),
+ ("blocked", models.BooleanField(default=False)),
+ ("public", models.BooleanField(default=False)),
+ ("default", models.BooleanField(default=False)),
+ ("notes", models.TextField(blank=True, null=True)),
+ ("created", models.DateTimeField(auto_now_add=True)),
+ ("updated", models.DateTimeField(auto_now=True)),
+ ],
+ options={
+ "db_table": "users_domain",
+ },
+ ),
+ migrations.CreateModel(
+ name="Emoji",
+ fields=[
+ (
+ "id",
+ models.BigAutoField(
+ auto_created=True,
+ primary_key=True,
+ serialize=False,
+ verbose_name="ID",
+ ),
+ ),
+ ("shortcode", models.SlugField(max_length=100)),
+ ("local", models.BooleanField(default=True)),
+ ("public", models.BooleanField(null=True)),
+ (
+ "object_uri",
+ models.CharField(
+ blank=True, max_length=500, null=True, unique=True
+ ),
+ ),
+ ("mimetype", models.CharField(max_length=200)),
+ ("file", models.ImageField(blank=True, null=True, upload_to="")),
+ ("remote_url", models.CharField(blank=True, max_length=500, null=True)),
+ ("category", models.CharField(blank=True, max_length=100, null=True)),
+ ("created", models.DateTimeField(auto_now_add=True)),
+ ("updated", models.DateTimeField(auto_now=True)),
+ (
+ "domain",
+ models.ForeignKey(
+ blank=True,
+ null=True,
+ on_delete=django.db.models.deletion.CASCADE,
+ to="takahe.domain",
+ ),
+ ),
+ ],
+ options={
+ "db_table": "activities_emoji",
+ },
+ ),
+ migrations.CreateModel(
+ name="Hashtag",
+ fields=[
+ (
+ "hashtag",
+ models.SlugField(max_length=100, primary_key=True, serialize=False),
+ ),
+ (
+ "name_override",
+ models.CharField(blank=True, max_length=100, null=True),
+ ),
+ ("public", models.BooleanField(null=True)),
+ ("state", models.CharField(default="outdated", max_length=100)),
+ ("state_changed", models.DateTimeField(auto_now_add=True)),
+ ("stats", models.JSONField(blank=True, null=True)),
+ ("stats_updated", models.DateTimeField(blank=True, null=True)),
+ ("aliases", models.JSONField(blank=True, null=True)),
+ ("created", models.DateTimeField(auto_now_add=True)),
+ ("updated", models.DateTimeField(auto_now=True)),
+ ],
+ options={
+ "db_table": "activities_hashtag",
+ },
+ ),
+ migrations.CreateModel(
+ name="Identity",
+ fields=[
+ (
+ "id",
+ models.BigIntegerField(
+ default=takahe.models.Snowflake.generate_identity,
+ primary_key=True,
+ serialize=False,
+ ),
+ ),
+ ("actor_uri", models.CharField(max_length=500, unique=True)),
+ ("state", models.CharField(default="outdated", max_length=100)),
+ ("state_changed", models.DateTimeField(auto_now_add=True)),
+ ("local", models.BooleanField(db_index=True)),
+ ("username", models.CharField(blank=True, max_length=500, null=True)),
+ ("name", models.CharField(blank=True, max_length=500, null=True)),
+ ("summary", models.TextField(blank=True, null=True)),
+ (
+ "manually_approves_followers",
+ models.BooleanField(blank=True, null=True),
+ ),
+ ("discoverable", models.BooleanField(default=True)),
+ (
+ "profile_uri",
+ models.CharField(blank=True, max_length=500, null=True),
+ ),
+ ("inbox_uri", models.CharField(blank=True, max_length=500, null=True)),
+ (
+ "shared_inbox_uri",
+ models.CharField(blank=True, max_length=500, null=True),
+ ),
+ ("outbox_uri", models.CharField(blank=True, max_length=500, null=True)),
+ ("icon_uri", models.CharField(blank=True, max_length=500, null=True)),
+ ("image_uri", models.CharField(blank=True, max_length=500, null=True)),
+ (
+ "followers_uri",
+ models.CharField(blank=True, max_length=500, null=True),
+ ),
+ (
+ "following_uri",
+ models.CharField(blank=True, max_length=500, null=True),
+ ),
+ (
+ "featured_collection_uri",
+ models.CharField(blank=True, max_length=500, null=True),
+ ),
+ ("actor_type", models.CharField(default="person", max_length=100)),
+ ("metadata", models.JSONField(blank=True, null=True)),
+ ("pinned", models.JSONField(blank=True, null=True)),
+ ("sensitive", models.BooleanField(default=False)),
+ (
+ "restriction",
+ models.IntegerField(
+ choices=[(0, "None"), (1, "Limited"), (2, "Blocked")],
+ db_index=True,
+ default=0,
+ ),
+ ),
+ ("admin_notes", models.TextField(blank=True, null=True)),
+ ("private_key", models.TextField(blank=True, null=True)),
+ ("public_key", models.TextField(blank=True, null=True)),
+ ("public_key_id", models.TextField(blank=True, null=True)),
+ ("created", models.DateTimeField(auto_now_add=True)),
+ ("updated", models.DateTimeField(auto_now=True)),
+ ("fetched", models.DateTimeField(blank=True, null=True)),
+ ("deleted", models.DateTimeField(blank=True, null=True)),
+ (
+ "domain",
+ models.ForeignKey(
+ blank=True,
+ null=True,
+ on_delete=django.db.models.deletion.PROTECT,
+ related_name="identities",
+ to="takahe.domain",
+ ),
+ ),
+ ],
+ options={
+ "verbose_name_plural": "identities",
+ "db_table": "users_identity",
+ },
+ ),
+ migrations.CreateModel(
+ name="Post",
+ fields=[
+ (
+ "id",
+ models.BigIntegerField(
+ default=takahe.models.Snowflake.generate_post,
+ primary_key=True,
+ serialize=False,
+ ),
+ ),
+ ("state", models.CharField(default="new", max_length=100)),
+ ("state_changed", models.DateTimeField(auto_now_add=True)),
+ ("local", models.BooleanField()),
+ (
+ "object_uri",
+ models.CharField(
+ blank=True, max_length=2048, null=True, unique=True
+ ),
+ ),
+ (
+ "visibility",
+ models.IntegerField(
+ choices=[
+ (0, "Public"),
+ (4, "Local Only"),
+ (1, "Unlisted"),
+ (2, "Followers"),
+ (3, "Mentioned"),
+ ],
+ default=0,
+ ),
+ ),
+ ("content", models.TextField()),
+ (
+ "type",
+ models.CharField(
+ choices=[
+ ("Article", "Article"),
+ ("Audio", "Audio"),
+ ("Event", "Event"),
+ ("Image", "Image"),
+ ("Note", "Note"),
+ ("Page", "Page"),
+ ("Question", "Question"),
+ ("Video", "Video"),
+ ],
+ default="Note",
+ max_length=20,
+ ),
+ ),
+ ("type_data", models.JSONField(blank=True, null=True)),
+ ("sensitive", models.BooleanField(default=False)),
+ ("summary", models.TextField(blank=True, null=True)),
+ ("url", models.CharField(blank=True, max_length=2048, null=True)),
+ (
+ "in_reply_to",
+ models.CharField(
+ blank=True, db_index=True, max_length=500, null=True
+ ),
+ ),
+ ("hashtags", models.JSONField(blank=True, null=True)),
+ ("stats", models.JSONField(blank=True, null=True)),
+ ("published", models.DateTimeField(default=django.utils.timezone.now)),
+ ("edited", models.DateTimeField(blank=True, null=True)),
+ ("created", models.DateTimeField(auto_now_add=True)),
+ ("updated", models.DateTimeField(auto_now=True)),
+ (
+ "author",
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="posts",
+ to="takahe.identity",
+ ),
+ ),
+ (
+ "emojis",
+ models.ManyToManyField(
+ blank=True, related_name="posts_using_emoji", to="takahe.emoji"
+ ),
+ ),
+ (
+ "mentions",
+ models.ManyToManyField(
+ blank=True,
+ related_name="posts_mentioning",
+ to="takahe.identity",
+ ),
+ ),
+ (
+ "to",
+ models.ManyToManyField(
+ blank=True, related_name="posts_to", to="takahe.identity"
+ ),
+ ),
+ ],
+ options={
+ "db_table": "activities_post",
+ },
+ ),
+ migrations.CreateModel(
+ name="User",
+ fields=[
+ (
+ "id",
+ models.BigAutoField(
+ auto_created=True,
+ primary_key=True,
+ serialize=False,
+ verbose_name="ID",
+ ),
+ ),
+ ("password", models.CharField(max_length=128, verbose_name="password")),
+ (
+ "last_login",
+ models.DateTimeField(
+ blank=True, null=True, verbose_name="last login"
+ ),
+ ),
+ ("email", models.EmailField(max_length=254, unique=True)),
+ ("admin", models.BooleanField(default=False)),
+ ("moderator", models.BooleanField(default=False)),
+ ("banned", models.BooleanField(default=False)),
+ ("deleted", models.BooleanField(default=False)),
+ ("created", models.DateTimeField(auto_now_add=True)),
+ ("updated", models.DateTimeField(auto_now=True)),
+ ("last_seen", models.DateTimeField(auto_now_add=True)),
+ ],
+ options={
+ "db_table": "users_user",
+ },
+ ),
+ migrations.CreateModel(
+ name="PostInteraction",
+ fields=[
+ (
+ "id",
+ models.BigIntegerField(
+ default=takahe.models.Snowflake.generate_post_interaction,
+ primary_key=True,
+ serialize=False,
+ ),
+ ),
+ ("state", models.CharField(default="new", max_length=100)),
+ ("state_changed", models.DateTimeField(auto_now_add=True)),
+ (
+ "object_uri",
+ models.CharField(
+ blank=True, max_length=500, null=True, unique=True
+ ),
+ ),
+ (
+ "type",
+ models.CharField(
+ choices=[
+ ("like", "Like"),
+ ("boost", "Boost"),
+ ("vote", "Vote"),
+ ("pin", "Pin"),
+ ],
+ max_length=100,
+ ),
+ ),
+ ("value", models.CharField(blank=True, max_length=50, null=True)),
+ ("published", models.DateTimeField(default=django.utils.timezone.now)),
+ ("created", models.DateTimeField(auto_now_add=True)),
+ ("updated", models.DateTimeField(auto_now=True)),
+ (
+ "identity",
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="interactions",
+ to="takahe.identity",
+ ),
+ ),
+ (
+ "post",
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="interactions",
+ to="takahe.post",
+ ),
+ ),
+ ],
+ options={
+ "db_table": "activities_postinteraction",
+ },
+ ),
+ migrations.AddField(
+ model_name="identity",
+ name="users",
+ field=models.ManyToManyField(
+ blank=True, related_name="identities", to="takahe.user"
+ ),
+ ),
+ migrations.AddField(
+ model_name="domain",
+ name="users",
+ field=models.ManyToManyField(
+ blank=True, related_name="domains", to="takahe.user"
+ ),
+ ),
+ migrations.CreateModel(
+ name="Block",
+ fields=[
+ (
+ "id",
+ models.BigAutoField(
+ auto_created=True,
+ primary_key=True,
+ serialize=False,
+ verbose_name="ID",
+ ),
+ ),
+ ("state", models.CharField(default="new", max_length=100)),
+ ("state_changed", models.DateTimeField(auto_now_add=True)),
+ ("uri", models.CharField(blank=True, max_length=500, null=True)),
+ ("mute", models.BooleanField()),
+ ("include_notifications", models.BooleanField(default=False)),
+ ("expires", models.DateTimeField(blank=True, null=True)),
+ ("note", models.TextField(blank=True, null=True)),
+ ("created", models.DateTimeField(auto_now_add=True)),
+ ("updated", models.DateTimeField(auto_now=True)),
+ (
+ "source",
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="outbound_blocks",
+ to="takahe.identity",
+ ),
+ ),
+ (
+ "target",
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="inbound_blocks",
+ to="takahe.identity",
+ ),
+ ),
+ ],
+ options={
+ "db_table": "users_block",
+ },
+ ),
+ migrations.AlterUniqueTogether(
+ name="identity",
+ unique_together={("username", "domain")},
+ ),
+ migrations.CreateModel(
+ name="Follow",
+ fields=[
+ (
+ "id",
+ models.BigIntegerField(
+ default=takahe.models.Snowflake.generate_follow,
+ primary_key=True,
+ serialize=False,
+ ),
+ ),
+ (
+ "boosts",
+ models.BooleanField(
+ default=True, help_text="Also follow boosts from this user"
+ ),
+ ),
+ ("uri", models.CharField(blank=True, max_length=500, null=True)),
+ ("note", models.TextField(blank=True, null=True)),
+ ("state", models.CharField(default="unrequested", max_length=100)),
+ ("state_changed", models.DateTimeField(auto_now_add=True)),
+ ("created", models.DateTimeField(auto_now_add=True)),
+ ("updated", models.DateTimeField(auto_now=True)),
+ (
+ "source",
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="outbound_follows",
+ to="takahe.identity",
+ ),
+ ),
+ (
+ "target",
+ models.ForeignKey(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="inbound_follows",
+ to="takahe.identity",
+ ),
+ ),
+ ],
+ options={
+ "db_table": "users_follow",
+ "unique_together": {("source", "target")},
+ },
+ ),
+ ]
diff --git a/takahe/migrations/__init__.py b/takahe/migrations/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/takahe/models.py b/takahe/models.py
new file mode 100644
index 00000000..c9879c12
--- /dev/null
+++ b/takahe/models.py
@@ -0,0 +1,1395 @@
+import datetime
+import re
+import secrets
+import ssl
+import time
+from datetime import date
+from functools import cached_property, partial
+from typing import TYPE_CHECKING, Literal, Optional
+from urllib.parse import urlparse
+
+import httpx
+import urlman
+from cachetools import TTLCache, cached
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding, rsa
+from django.conf import settings
+from django.contrib.auth.models import AbstractBaseUser, BaseUserManager
+from django.db import models, transaction
+from django.template.defaultfilters import linebreaks_filter
+from django.utils import timezone
+from django.utils.safestring import mark_safe
+from loguru import logger
+from lxml import etree
+
+from .html import FediverseHtmlParser
+from .uris import *
+
+if TYPE_CHECKING:
+ from django.db.models.manager import RelatedManager
+
+
+class Snowflake:
+ """
+ Snowflake ID generator and parser.
+ """
+
+ # Epoch is 2022/1/1 at midnight, as these are used for _created_ times in our
+ # own database, not original publish times (which would need an earlier one)
+ EPOCH = 1641020400
+
+ TYPE_POST = 0b000
+ TYPE_POST_INTERACTION = 0b001
+ TYPE_IDENTITY = 0b010
+ TYPE_REPORT = 0b011
+ TYPE_FOLLOW = 0b100
+
+ @classmethod
+ def generate(cls, type_id: int) -> int:
+ """
+ Generates a snowflake-style ID for the given "type". They are designed
+ to fit inside 63 bits (a signed bigint)
+
+ ID layout is:
+ * 41 bits of millisecond-level timestamp (enough for EPOCH + 69 years)
+ * 19 bits of random data (1% chance of clash at 10000 per millisecond)
+ * 3 bits of type information
+
+ We use random data rather than a sequence ID to try and avoid pushing
+ this job onto the DB - we may do that in future. If a clash does
+ occur, the insert will fail and Stator will retry the work for anything
+ that's coming in remotely, leaving us to just handle that scenario for
+ our own posts, likes, etc.
+ """
+ # Get the current time in milliseconds
+ now: int = int((time.time() - cls.EPOCH) * 1000)
+ # Generate random data
+ rand_seq: int = secrets.randbits(19)
+ # Compose them together
+ return (now << 22) | (rand_seq << 3) | type_id
+
+ @classmethod
+ def get_type(cls, snowflake: int) -> int:
+ """
+ Returns the type of a given snowflake ID
+ """
+ if snowflake < (1 << 22):
+ raise ValueError("Not a valid Snowflake ID")
+ return snowflake & 0b111
+
+ @classmethod
+ def get_time(cls, snowflake: int) -> float:
+ """
+ Returns the generation time (in UNIX timestamp seconds) of the ID
+ """
+ if snowflake < (1 << 22):
+ raise ValueError("Not a valid Snowflake ID")
+ return ((snowflake >> 22) / 1000) + cls.EPOCH
+
+ # Handy pre-baked methods for django model defaults
+ @classmethod
+ def generate_post(cls) -> int:
+ return cls.generate(cls.TYPE_POST)
+
+ @classmethod
+ def generate_post_interaction(cls) -> int:
+ return cls.generate(cls.TYPE_POST_INTERACTION)
+
+ @classmethod
+ def generate_identity(cls) -> int:
+ return cls.generate(cls.TYPE_IDENTITY)
+
+ @classmethod
+ def generate_report(cls) -> int:
+ return cls.generate(cls.TYPE_REPORT)
+
+ @classmethod
+ def generate_follow(cls) -> int:
+ return cls.generate(cls.TYPE_FOLLOW)
+
+
+class RsaKeys:
+ @classmethod
+ def generate_keypair(cls) -> tuple[str, str]:
+ """
+ Generates a new RSA keypair
+ """
+ private_key = rsa.generate_private_key(
+ public_exponent=65537,
+ key_size=2048,
+ )
+ private_key_serialized = private_key.private_bytes(
+ encoding=serialization.Encoding.PEM,
+ format=serialization.PrivateFormat.PKCS8,
+ encryption_algorithm=serialization.NoEncryption(),
+ ).decode("ascii")
+ public_key_serialized = (
+ private_key.public_key()
+ .public_bytes(
+ encoding=serialization.Encoding.PEM,
+ format=serialization.PublicFormat.SubjectPublicKeyInfo,
+ )
+ .decode("ascii")
+ )
+ return private_key_serialized, public_key_serialized
+
+
+class User(AbstractBaseUser):
+ identities: "RelatedManager[Identity]"
+
+ class Meta:
+ # managed = False
+ db_table = "users_user"
+
+ email = models.EmailField(unique=True)
+ admin = models.BooleanField(default=False)
+ moderator = models.BooleanField(default=False)
+ banned = models.BooleanField(default=False)
+ deleted = models.BooleanField(default=False)
+ created = models.DateTimeField(auto_now_add=True)
+ updated = models.DateTimeField(auto_now=True)
+ last_seen = models.DateTimeField(auto_now_add=True)
+ USERNAME_FIELD = "email"
+ EMAIL_FIELD = "email"
+ REQUIRED_FIELDS: list[str] = []
+
+ @property
+ def is_active(self):
+ return not (self.deleted or self.banned)
+
+ @property
+ def is_superuser(self):
+ return self.admin
+
+ @property
+ def is_staff(self):
+ return self.admin
+
+ def has_module_perms(self, module):
+ return self.admin
+
+ def has_perm(self, perm):
+ return self.admin
+
+ # @cached_property
+ # def config_user(self) -> Config.UserOptions:
+ # return Config.load_user(self)
+
+
+class Domain(models.Model):
+ """
+ Represents a domain that a user can have an account on.
+
+ For protocol reasons, if we want to allow custom usernames
+ per domain, each "display" domain (the one in the handle) must either let
+ us serve on it directly, or have a "service" domain that maps
+ to it uniquely that we can serve on that.
+
+ That way, someone coming in with just an Actor URI as their
+ entrypoint can still try to webfinger preferredUsername@actorDomain
+ and we can return an appropriate response.
+
+ It's possible to just have one domain do both jobs, of course.
+ This model also represents _other_ servers' domains, which we treat as
+ display domains for now, until we start doing better probing.
+ """
+
+ domain = models.CharField(max_length=250, primary_key=True)
+ service_domain = models.CharField(
+ max_length=250,
+ null=True,
+ blank=True,
+ db_index=True,
+ unique=True,
+ )
+
+ # state = StateField(DomainStates)
+ state = models.CharField(max_length=100, default="outdated")
+ state_changed = models.DateTimeField(auto_now_add=True)
+
+ # nodeinfo 2.0 detail about the remote server
+ nodeinfo = models.JSONField(null=True, blank=True)
+
+ # If we own this domain
+ local = models.BooleanField()
+
+ # If we have blocked this domain from interacting with us
+ blocked = models.BooleanField(default=False)
+
+ # Domains can be joinable by any user of the instance (as the default one
+ # should)
+ public = models.BooleanField(default=False)
+
+ # If this is the default domain (shown as the default entry for new users)
+ default = models.BooleanField(default=False)
+
+ # Domains can also be linked to one or more users for their private use
+ # This should be display domains ONLY
+ users = models.ManyToManyField("takahe.User", related_name="domains", blank=True)
+
+ # Free-form notes field for admins
+ notes = models.TextField(blank=True, null=True)
+
+ created = models.DateTimeField(auto_now_add=True)
+ updated = models.DateTimeField(auto_now=True)
+
+ class urls(urlman.Urls):
+ root = "/admin/domains/"
+ create = "/admin/domains/create/"
+ edit = "/admin/domains/{self.domain}/"
+ delete = "{edit}delete/"
+ root_federation = "/admin/federation/"
+ edit_federation = "/admin/federation/{self.domain}/"
+
+ class Meta:
+ # managed = False
+ db_table = "users_domain"
+ indexes: list = []
+
+ @classmethod
+ def get_remote_domain(cls, domain: str) -> "Domain":
+ return cls.objects.get_or_create(domain=domain.lower(), local=False)[0]
+
+ @classmethod
+ def get_domain(cls, domain: str) -> Optional["Domain"]:
+ try:
+ return cls.objects.get(
+ models.Q(domain=domain.lower())
+ | models.Q(service_domain=domain.lower())
+ )
+ except cls.DoesNotExist:
+ return None
+
+ @property
+ def uri_domain(self) -> str:
+ if self.service_domain:
+ return self.service_domain
+ return self.domain
+
+ @classmethod
+ def available_for_user(cls, user):
+ """
+ Returns domains that are available for the user to put an identity on
+ """
+ return cls.objects.filter(
+ models.Q(public=True) | models.Q(users__id=user.id),
+ local=True,
+ ).order_by("-default", "domain")
+
+ def __str__(self):
+ return self.domain
+
+
+class Identity(models.Model):
+ """
+ Represents both local and remote Fediverse identities (actors)
+ """
+
+ domain_id: int
+
+ class Restriction(models.IntegerChoices):
+ none = 0
+ limited = 1
+ blocked = 2
+
+ ACTOR_TYPES = ["person", "service", "application", "group", "organization"]
+
+ id = models.BigIntegerField(primary_key=True, default=Snowflake.generate_identity)
+
+ # The Actor URI is essentially also a PK - we keep the default numeric
+ # one around as well for making nice URLs etc.
+ actor_uri = models.CharField(max_length=500, unique=True)
+
+ # state = StateField(IdentityStates)
+ state = models.CharField(max_length=100, default="outdated")
+ state_changed = models.DateTimeField(auto_now_add=True)
+
+ local = models.BooleanField(db_index=True)
+ users = models.ManyToManyField(
+ "takahe.User",
+ related_name="identities",
+ blank=True,
+ )
+
+ username = models.CharField(max_length=500, blank=True, null=True)
+ # Must be a display domain if present
+ domain = models.ForeignKey(
+ Domain,
+ blank=True,
+ null=True,
+ on_delete=models.PROTECT,
+ related_name="identities",
+ )
+
+ name = models.CharField(max_length=500, blank=True, null=True)
+ summary = models.TextField(blank=True, null=True)
+ manually_approves_followers = models.BooleanField(blank=True, null=True)
+ discoverable = models.BooleanField(default=True)
+
+ profile_uri = models.CharField(max_length=500, blank=True, null=True)
+ inbox_uri = models.CharField(max_length=500, blank=True, null=True)
+ shared_inbox_uri = models.CharField(max_length=500, blank=True, null=True)
+ outbox_uri = models.CharField(max_length=500, blank=True, null=True)
+ icon_uri = models.CharField(max_length=500, blank=True, null=True)
+ image_uri = models.CharField(max_length=500, blank=True, null=True)
+ followers_uri = models.CharField(max_length=500, blank=True, null=True)
+ following_uri = models.CharField(max_length=500, blank=True, null=True)
+ featured_collection_uri = models.CharField(max_length=500, blank=True, null=True)
+ actor_type = models.CharField(max_length=100, default="person")
+
+ # icon = models.ImageField(
+ # upload_to=partial(upload_namer, "profile_images"), blank=True, null=True
+ # )
+ # image = models.ImageField(
+ # upload_to=partial(upload_namer, "background_images"), blank=True, null=True
+ # )
+
+ # Should be a list of {"name":..., "value":...} dicts
+ metadata = models.JSONField(blank=True, null=True)
+
+ # Should be a list of object URIs (we don't want a full M2M here)
+ pinned = models.JSONField(blank=True, null=True)
+
+ # Admin-only moderation fields
+ sensitive = models.BooleanField(default=False)
+ restriction = models.IntegerField(
+ choices=Restriction.choices, default=Restriction.none, db_index=True
+ )
+ admin_notes = models.TextField(null=True, blank=True)
+
+ private_key = models.TextField(null=True, blank=True)
+ public_key = models.TextField(null=True, blank=True)
+ public_key_id = models.TextField(null=True, blank=True)
+
+ created = models.DateTimeField(auto_now_add=True)
+ updated = models.DateTimeField(auto_now=True)
+ fetched = models.DateTimeField(null=True, blank=True)
+ deleted = models.DateTimeField(null=True, blank=True)
+
+ # objects = IdentityManager()
+
+ ### Model attributes ###
+
+ class Meta:
+ # managed = False
+ db_table = "users_identity"
+ verbose_name_plural = "identities"
+ unique_together = [("username", "domain")]
+ indexes: list = [] # We need this so Stator can add its own
+
+ class urls(urlman.Urls):
+ view = "/@{self.username}@{self.domain_id}/"
+ replies = "{view}replies/"
+ settings = "{view}settings/"
+ action = "{view}action/"
+ followers = "{view}followers/"
+ following = "{view}following/"
+ search = "{view}search/"
+ activate = "{view}activate/"
+ admin = "/admin/identities/"
+ admin_edit = "{admin}{self.pk}/"
+ djadmin_edit = "/djadmin/users/identity/{self.id}/change/"
+
+ def get_scheme(self, url):
+ return "https"
+
+ def get_hostname(self, url):
+ return self.instance.domain.uri_domain
+
+ def __str__(self):
+ if self.username and self.domain:
+ return self.handle
+ return self.actor_uri
+
+ def absolute_profile_uri(self):
+ """
+ Returns a profile URI that is always absolute, for sending out to
+ other servers.
+ """
+ if self.local:
+ return f"https://{self.domain.uri_domain}/@{self.username}/"
+ else:
+ return self.profile_uri
+
+ @property
+ def handle(self):
+ if self.username is None:
+ return "(unknown user)"
+ if self.domain_id:
+ return f"{self.username}@{self.domain_id}"
+ return f"{self.username}@(unknown server)"
+
+ @property
+ def user_pk(self):
+ user = self.users.first()
+ return user.pk if user else None
+
+ @classmethod
+ def fetch_webfinger_url(cls, domain: str) -> str:
+ """
+ Given a domain (hostname), returns the correct webfinger URL to use
+ based on probing host-meta.
+ """
+ with httpx.Client(
+ timeout=settings.SETUP.REMOTE_TIMEOUT,
+ headers={"User-Agent": settings.TAKAHE_USER_AGENT},
+ ) as client:
+ try:
+ response = client.get(
+ f"https://{domain}/.well-known/host-meta",
+ follow_redirects=True,
+ headers={"Accept": "application/xml"},
+ )
+
+ # In the case of anything other than a success, we'll still try
+ # hitting the webfinger URL on the domain we were given to handle
+ # incorrectly setup servers.
+ if response.status_code == 200 and response.content.strip():
+ tree = etree.fromstring(response.content)
+ template = tree.xpath(
+ "string(.//*[local-name() = 'Link' and @rel='lrdd' and (not(@type) or @type='application/jrd+json')]/@template)"
+ )
+ if template:
+ return template # type: ignore
+ except (httpx.RequestError, etree.ParseError):
+ pass
+
+ return f"https://{domain}/.well-known/webfinger?resource={{uri}}"
+
+ @classmethod
+ def fetch_webfinger(cls, handle: str) -> tuple[str | None, str | None]:
+ """
+ Given a username@domain handle, returns a tuple of
+ (actor uri, canonical handle) or None, None if it does not resolve.
+ """
+ domain = handle.split("@")[1].lower()
+ try:
+ webfinger_url = cls.fetch_webfinger_url(domain)
+ except ssl.SSLCertVerificationError:
+ return None, None
+
+ # Go make a Webfinger request
+ with httpx.Client(
+ timeout=settings.SETUP.REMOTE_TIMEOUT,
+ headers={"User-Agent": settings.TAKAHE_USER_AGENT},
+ ) as client:
+ try:
+ response = client.get(
+ webfinger_url.format(uri=f"acct:{handle}"),
+ follow_redirects=True,
+ headers={"Accept": "application/json"},
+ )
+ response.raise_for_status()
+ except (httpx.HTTPError, ssl.SSLCertVerificationError) as ex:
+ response = getattr(ex, "response", None)
+ if (
+ response
+ and response.status_code < 500
+ and response.status_code not in [400, 401, 403, 404, 406, 410]
+ ):
+ raise ValueError(
+ f"Client error fetching webfinger: {response.status_code}",
+ response.content,
+ )
+ return None, None
+
+ try:
+ data = response.json()
+ except ValueError:
+ # Some servers return these with a 200 status code!
+ if b"not found" in response.content.lower():
+ return None, None
+ raise ValueError(
+ "JSON parse error fetching webfinger",
+ response.content,
+ )
+ try:
+ if data["subject"].startswith("acct:"):
+ data["subject"] = data["subject"][5:]
+ for link in data["links"]:
+ if (
+ link.get("type") == "application/activity+json"
+ and link.get("rel") == "self"
+ ):
+ return link["href"], data["subject"]
+ except KeyError:
+ # Server returning wrong payload structure
+ pass
+ return None, None
+
+ @classmethod
+ def by_username_and_domain(
+ cls,
+ username: str,
+ domain: str | Domain,
+ fetch: bool = False,
+ local: bool = False,
+ ):
+ """
+ Get an Identity by username and domain.
+
+ When fetch is True, a failed lookup will do a webfinger lookup to attempt to do
+ a lookup by actor_uri, creating an Identity record if one does not exist. When
+ local is True, lookups will be restricted to local domains.
+
+ If domain is a Domain, domain.local is used instead of passsed local.
+
+ """
+ if username.startswith("@"):
+ raise ValueError("Username must not start with @")
+
+ domain_instance = None
+
+ if isinstance(domain, Domain):
+ domain_instance = domain
+ local = domain.local
+ domain = domain.domain
+ else:
+ domain = domain.lower()
+ try:
+ if local:
+ return cls.objects.get(
+ username__iexact=username,
+ domain_id=domain,
+ local=True,
+ )
+ else:
+ return cls.objects.get(
+ username__iexact=username,
+ domain_id=domain,
+ )
+ except cls.DoesNotExist:
+ if fetch and not local:
+ actor_uri, handle = cls.fetch_webfinger(f"{username}@{domain}")
+ if handle is None:
+ return None
+ # See if this actually does match an existing actor
+ try:
+ return cls.objects.get(actor_uri=actor_uri)
+ except cls.DoesNotExist:
+ pass
+ # OK, make one
+ username, domain = handle.split("@")
+ if not domain_instance:
+ domain_instance = Domain.get_remote_domain(domain)
+ return cls.objects.create(
+ actor_uri=actor_uri,
+ username=username,
+ domain_id=domain_instance,
+ local=False,
+ )
+ return None
+
+ def generate_keypair(self):
+ if not self.local:
+ raise ValueError("Cannot generate keypair for remote user")
+ self.private_key, self.public_key = RsaKeys.generate_keypair()
+ self.public_key_id = self.actor_uri + "#main-key"
+ self.save()
+
+
+class Follow(models.Model):
+ """
+ When one user (the source) follows other (the target)
+ """
+
+ id = models.BigIntegerField(primary_key=True, default=Snowflake.generate_follow)
+
+ source = models.ForeignKey(
+ "takahe.Identity",
+ on_delete=models.CASCADE,
+ related_name="outbound_follows",
+ )
+ target = models.ForeignKey(
+ "takahe.Identity",
+ on_delete=models.CASCADE,
+ related_name="inbound_follows",
+ )
+
+ boosts = models.BooleanField(
+ default=True, help_text="Also follow boosts from this user"
+ )
+
+ uri = models.CharField(blank=True, null=True, max_length=500)
+ note = models.TextField(blank=True, null=True)
+
+ # state = StateField(FollowStates)
+ state = models.CharField(max_length=100, default="unrequested")
+ state_changed = models.DateTimeField(auto_now_add=True)
+
+ created = models.DateTimeField(auto_now_add=True)
+ updated = models.DateTimeField(auto_now=True)
+
+ class Meta:
+ # managed = False
+ db_table = "users_follow"
+ unique_together = [("source", "target")]
+ indexes: list = [] # We need this so Stator can add its own
+
+ def __str__(self):
+ return f"#{self.id}: {self.source} → {self.target}"
+
+
+class Post(models.Model):
+ """
+ A post (status, toot) that is either local or remote.
+ """
+
+ interactions: "models.QuerySet[PostInteraction]"
+
+ class Visibilities(models.IntegerChoices):
+ public = 0
+ local_only = 4
+ unlisted = 1
+ followers = 2
+ mentioned = 3
+
+ class Types(models.TextChoices):
+ article = "Article"
+ audio = "Audio"
+ event = "Event"
+ image = "Image"
+ note = "Note"
+ page = "Page"
+ question = "Question"
+ video = "Video"
+
+ id = models.BigIntegerField(primary_key=True, default=Snowflake.generate_post)
+
+ # The author (attributedTo) of the post
+ author = models.ForeignKey(
+ "takahe.Identity",
+ on_delete=models.CASCADE,
+ related_name="posts",
+ )
+
+ # The state the post is in
+ # state = StateField(PostStates)
+ state = models.CharField(max_length=100, default="new")
+ state_changed = models.DateTimeField(auto_now_add=True)
+
+ # If it is our post or not
+ local = models.BooleanField()
+
+ # The canonical object ID
+ object_uri = models.CharField(max_length=2048, blank=True, null=True, unique=True)
+
+ # Who should be able to see this Post
+ visibility = models.IntegerField(
+ choices=Visibilities.choices,
+ default=Visibilities.public,
+ )
+
+ # The main (HTML) content
+ content = models.TextField()
+
+ type = models.CharField(
+ max_length=20,
+ choices=Types.choices,
+ default=Types.note,
+ )
+ type_data = models.JSONField(
+ blank=True,
+ null=True, # , encoder=PostTypeDataEncoder, decoder=PostTypeDataDecoder
+ )
+
+ # If the contents of the post are sensitive, and the summary (content
+ # warning) to show if it is
+ sensitive = models.BooleanField(default=False)
+ summary = models.TextField(blank=True, null=True)
+
+ # The public, web URL of this Post on the original server
+ url = models.CharField(max_length=2048, blank=True, null=True)
+
+ # The Post it is replying to as an AP ID URI
+ # (as otherwise we'd have to pull entire threads to use IDs)
+ in_reply_to = models.CharField(max_length=500, blank=True, null=True, db_index=True)
+
+ # The identities the post is directly to (who can see it if not public)
+ to = models.ManyToManyField(
+ "takahe.Identity",
+ related_name="posts_to",
+ blank=True,
+ )
+
+ # The identities mentioned in the post
+ mentions = models.ManyToManyField(
+ "takahe.Identity",
+ related_name="posts_mentioning",
+ blank=True,
+ )
+
+ # Hashtags in the post
+ hashtags = models.JSONField(blank=True, null=True)
+
+ emojis = models.ManyToManyField(
+ "takahe.Emoji",
+ related_name="posts_using_emoji",
+ blank=True,
+ )
+
+ # Like/Boost/etc counts
+ stats = models.JSONField(blank=True, null=True)
+
+ # When the post was originally created (as opposed to when we received it)
+ published = models.DateTimeField(default=timezone.now)
+
+ # If the post has been edited after initial publication
+ edited = models.DateTimeField(blank=True, null=True)
+
+ created = models.DateTimeField(auto_now_add=True)
+ updated = models.DateTimeField(auto_now=True)
+
+ class Meta:
+ # managed = False
+ db_table = "activities_post"
+
+ class urls(urlman.Urls):
+ view = "{self.author.urls.view}posts/{self.id}/"
+ object_uri = "{self.author.actor_uri}posts/{self.id}/"
+ action_like = "{view}like/"
+ action_unlike = "{view}unlike/"
+ action_boost = "{view}boost/"
+ action_unboost = "{view}unboost/"
+ action_bookmark = "{view}bookmark/"
+ action_unbookmark = "{view}unbookmark/"
+ action_delete = "{view}delete/"
+ action_edit = "{view}edit/"
+ action_report = "{view}report/"
+ action_reply = "/compose/?reply_to={self.id}"
+ admin_edit = "/djadmin/activities/post/{self.id}/change/"
+
+ def get_scheme(self, url):
+ return "https"
+
+ def get_hostname(self, url):
+ return self.instance.author.domain.uri_domain
+
+ def __str__(self):
+ return f"{self.author} #{self.id}"
+
+ def get_absolute_url(self):
+ return self.urls.view
+
+ def absolute_object_uri(self):
+ """
+ Returns an object URI that is always absolute, for sending out to
+ other servers.
+ """
+ if self.local:
+ return self.author.absolute_profile_uri() + f"posts/{self.id}/"
+ else:
+ return self.object_uri
+
+ def in_reply_to_post(self) -> Optional["Post"]:
+ """
+ Returns the actual Post object we're replying to, if we can find it
+ """
+ if self.in_reply_to is None:
+ return None
+ return (
+ Post.objects.filter(object_uri=self.in_reply_to)
+ .select_related("author")
+ .first()
+ )
+
+ @classmethod
+ def create_local(
+ cls,
+ author: Identity,
+ raw_prepend_content: str,
+ content: str,
+ summary: str | None = None,
+ sensitive: bool = False,
+ visibility: int = Visibilities.public,
+ reply_to: Optional["Post"] = None,
+ attachments: list | None = None,
+ type_data: dict | None = None,
+ published: datetime.datetime | None = None,
+ ) -> "Post":
+ with transaction.atomic():
+ # Find mentions in this post
+ mentions = cls.mentions_from_content(content, author)
+ # mentions = set()
+ if reply_to:
+ mentions.add(reply_to.author)
+ # Maintain local-only for replies
+ if reply_to.visibility == reply_to.Visibilities.local_only:
+ visibility = reply_to.Visibilities.local_only
+ # Find emoji in this post
+ emojis = Emoji.emojis_from_content(content, None)
+ # Strip all unwanted HTML and apply linebreaks filter, grabbing hashtags on the way
+ parser = FediverseHtmlParser(linebreaks_filter(content), find_hashtags=True)
+ content = parser.html.replace("
", "
" + raw_prepend_content, 1)
+ hashtags = (
+ sorted([tag[: Hashtag.MAXIMUM_LENGTH] for tag in parser.hashtags])
+ or None
+ )
+ # Make the Post object
+ post = cls.objects.create(
+ author=author,
+ content=content,
+ summary=summary or None,
+ sensitive=bool(summary) or sensitive,
+ local=True,
+ visibility=visibility,
+ hashtags=hashtags,
+ in_reply_to=reply_to.object_uri if reply_to else None,
+ )
+ post.object_uri = post.urls.object_uri
+ post.url = post.absolute_object_uri()
+ post.mentions.set(mentions)
+ post.emojis.set(emojis)
+ if published and published < timezone.now():
+ post.published = published
+ if timezone.now() - published > datetime.timedelta(days=2):
+ post.state = "fanned_out" # add post quietly if it's old
+ # if attachments:# FIXME
+ # post.attachments.set(attachments)
+ # if question: # FIXME
+ # post.type = question["type"]
+ # post.type_data = PostTypeData(__root__=question).__root__
+ if type_data:
+ post.type_data = type_data
+ post.save()
+ # Recalculate parent stats for replies
+ if reply_to:
+ reply_to.calculate_stats()
+ return post
+
+ def edit_local(
+ self,
+ raw_prepend_content: str,
+ content: str,
+ summary: str | None = None,
+ sensitive: bool | None = None,
+ visibility: int = Visibilities.public,
+ attachments: list | None = None,
+ attachment_attributes: list | None = None,
+ type_data: dict | None = None,
+ ):
+ with transaction.atomic():
+ # Strip all HTML and apply linebreaks filter
+ parser = FediverseHtmlParser(linebreaks_filter(content), find_hashtags=True)
+ self.content = parser.html.replace("
", "
" + raw_prepend_content, 1)
+ self.hashtags = (
+ sorted([tag[: Hashtag.MAXIMUM_LENGTH] for tag in parser.hashtags])
+ or None
+ )
+ self.summary = summary or None
+ self.sensitive = bool(summary) if sensitive is None else sensitive
+ self.visibility = visibility
+ self.edited = timezone.now()
+ self.mentions.set(self.mentions_from_content(content, self.author))
+ self.emojis.set(Emoji.emojis_from_content(content, None))
+ # self.attachments.set(attachments or []) # fixme
+ if type_data:
+ self.type_data = type_data
+ self.save()
+
+ for attrs in attachment_attributes or []:
+ attachment = next(
+ (a for a in attachments or [] if str(a.id) == attrs.id), None
+ )
+ if attachment is None:
+ continue
+ attachment.name = attrs.description
+ attachment.save()
+
+ self.state = "edited"
+ self.state_changed = timezone.now()
+ self.state_next_attempt = None
+ self.state_locked_until = None
+ self.save()
+
+ @classmethod
+ def mentions_from_content(cls, content, author) -> set[Identity]:
+ mention_hits = FediverseHtmlParser(content, find_mentions=True).mentions
+ mentions = set()
+ for handle in mention_hits:
+ handle = handle.lower()
+ if "@" in handle:
+ username, domain = handle.split("@", 1)
+ else:
+ username = handle
+ domain = author.domain_id
+ identity = Identity.by_username_and_domain(
+ username=username,
+ domain=domain,
+ fetch=True,
+ )
+ if identity is not None:
+ mentions.add(identity)
+ return mentions
+
+ def ensure_hashtags(self) -> None:
+ """
+ Ensure any of the already parsed hashtags from this Post
+ have a corresponding Hashtag record.
+ """
+ # Ensure hashtags
+ if self.hashtags:
+ for hashtag in self.hashtags:
+ tag, _ = Hashtag.objects.get_or_create(
+ hashtag=hashtag[: Hashtag.MAXIMUM_LENGTH],
+ )
+ tag.transition_perform("outdated")
+
+ def calculate_stats(self, save=True):
+ """
+ Recalculates our stats dict
+ """
+ from .models import PostInteraction
+
+ self.stats = {
+ "likes": self.interactions.filter(
+ type=PostInteraction.Types.like,
+ state__in=["new", "fanned_out"],
+ ).count(),
+ "boosts": self.interactions.filter(
+ type=PostInteraction.Types.boost,
+ state__in=["new", "fanned_out"],
+ ).count(),
+ "replies": Post.objects.filter(in_reply_to=self.object_uri).count(),
+ }
+ if save:
+ self.save()
+
+
+class EmojiQuerySet(models.QuerySet):
+ def usable(self, domain: Domain | None = None):
+ """
+ Returns all usable emoji, optionally filtering by domain too.
+ """
+ visible_q = models.Q(local=True) | models.Q(public=True)
+ if True: # Config.system.emoji_unreviewed_are_public:
+ visible_q |= models.Q(public__isnull=True)
+ qs = self.filter(visible_q)
+
+ if domain:
+ if not domain.local:
+ qs = qs.filter(domain=domain)
+
+ return qs
+
+
+class EmojiManager(models.Manager):
+ def get_queryset(self):
+ return EmojiQuerySet(self.model, using=self._db)
+
+ def usable(self, domain: Domain | None = None):
+ return self.get_queryset().usable(domain)
+
+
+class Emoji(models.Model):
+ class Meta:
+ # managed = False
+ db_table = "activities_emoji"
+
+ # Normalized Emoji without the ':'
+ shortcode = models.SlugField(max_length=100, db_index=True)
+
+ domain = models.ForeignKey(
+ "takahe.Domain", null=True, blank=True, on_delete=models.CASCADE
+ )
+ local = models.BooleanField(default=True)
+
+ # Should this be shown in the public UI?
+ public = models.BooleanField(null=True)
+
+ object_uri = models.CharField(max_length=500, blank=True, null=True, unique=True)
+
+ mimetype = models.CharField(max_length=200)
+
+ # Files may not be populated if it's remote and not cached on our side yet
+ file = models.ImageField(
+ # upload_to=partial(upload_emoji_namer, "emoji"),
+ null=True,
+ blank=True,
+ )
+
+ # A link to the custom emoji
+ remote_url = models.CharField(max_length=500, blank=True, null=True)
+
+ # Used for sorting custom emoji in the picker
+ category = models.CharField(max_length=100, blank=True, null=True)
+
+ # State of this Emoji
+ # state = StateField(EmojiStates)
+
+ created = models.DateTimeField(auto_now_add=True)
+ updated = models.DateTimeField(auto_now=True)
+
+ objects = EmojiManager()
+
+ @classmethod
+ def emojis_from_content(cls, content: str, domain: Domain | None) -> list["Emoji"]:
+ """
+ Return a parsed and sanitized of emoji found in content without
+ the surrounding ':'.
+ """
+ emoji_hits = FediverseHtmlParser(
+ content, find_emojis=True, emoji_domain=domain
+ ).emojis
+ emojis = sorted({emoji for emoji in emoji_hits})
+ q = models.Q(local=True) | models.Q(public=True) | models.Q(public__isnull=True)
+ if domain and not domain.local:
+ q = q & models.Q(domain=domain)
+ return list(
+ cls.objects.filter(local=(domain is None) or domain.local)
+ .filter(q)
+ .filter(shortcode__in=emojis)
+ )
+
+ @classmethod
+ @cached(cache=TTLCache(maxsize=1000, ttl=60))
+ def get_by_domain(cls, shortcode, domain: Domain | None) -> "Emoji | None":
+ """
+ Given an emoji shortcode and optional domain, looks up the single
+ emoji and returns it. Raises Emoji.DoesNotExist if there isn't one.
+ """
+ try:
+ if domain is None or domain.local:
+ return cls.objects.get(local=True, shortcode=shortcode)
+ else:
+ return cls.objects.get(domain=domain, shortcode=shortcode)
+ except Emoji.DoesNotExist:
+ return None
+
+ @property
+ def fullcode(self):
+ return f":{self.shortcode}:"
+
+ @property
+ def is_usable(self) -> bool:
+ """
+ Return True if this Emoji is usable.
+ """
+ return self.public or self.public is None
+
+ def full_url(self, always_show=False) -> RelativeAbsoluteUrl:
+ if self.is_usable or always_show:
+ if self.file:
+ return AutoAbsoluteUrl(self.file.url)
+ elif self.remote_url:
+ return ProxyAbsoluteUrl(
+ f"/proxy/emoji/{self.pk}/",
+ remote_url=self.remote_url,
+ )
+ return StaticAbsoluteUrl("img/blank-emoji-128.png")
+
+ def as_html(self):
+ if self.is_usable:
+ return mark_safe(
+ f'.relative})
'
+ )
+ return self.fullcode
+
+
+class HashtagQuerySet(models.QuerySet):
+ def public(self):
+ public_q = models.Q(public=True)
+ if True: # Config.system.hashtag_unreviewed_are_public:
+ public_q |= models.Q(public__isnull=True)
+ return self.filter(public_q)
+
+ def hashtag_or_alias(self, hashtag: str):
+ return self.filter(
+ models.Q(hashtag=hashtag) | models.Q(aliases__contains=hashtag)
+ )
+
+
+class HashtagManager(models.Manager):
+ def get_queryset(self):
+ return HashtagQuerySet(self.model, using=self._db)
+
+ def public(self):
+ return self.get_queryset().public()
+
+ def hashtag_or_alias(self, hashtag: str):
+ return self.get_queryset().hashtag_or_alias(hashtag)
+
+
+class Hashtag(models.Model):
+ class Meta:
+ # managed = False
+ db_table = "activities_hashtag"
+
+ MAXIMUM_LENGTH = 100
+
+ # Normalized hashtag without the '#'
+ hashtag = models.SlugField(primary_key=True, max_length=100)
+
+ # Friendly display override
+ name_override = models.CharField(max_length=100, null=True, blank=True)
+
+ # Should this be shown in the public UI?
+ public = models.BooleanField(null=True)
+
+ # State of this Hashtag
+ # state = StateField(HashtagStates)
+ state = models.CharField(max_length=100, default="outdated")
+ state_changed = models.DateTimeField(auto_now_add=True)
+
+ # Metrics for this Hashtag
+ stats = models.JSONField(null=True, blank=True)
+ # Timestamp of last time the stats were updated
+ stats_updated = models.DateTimeField(null=True, blank=True)
+
+ # List of other hashtags that are considered similar
+ aliases = models.JSONField(null=True, blank=True)
+
+ created = models.DateTimeField(auto_now_add=True)
+ updated = models.DateTimeField(auto_now=True)
+
+ objects = HashtagManager()
+
+ class urls(urlman.Urls):
+ view = "/tags/{self.hashtag}/"
+ follow = "/tags/{self.hashtag}/follow/"
+ unfollow = "/tags/{self.hashtag}/unfollow/"
+ admin = "/admin/hashtags/"
+ admin_edit = "{admin}{self.hashtag}/"
+ admin_enable = "{admin_edit}enable/"
+ admin_disable = "{admin_edit}disable/"
+ timeline = "/tags/{self.hashtag}/"
+
+ hashtag_regex = re.compile(r"\B#([a-zA-Z0-9(_)]+\b)(?!;)")
+
+ def save(self, *args, **kwargs):
+ self.hashtag = self.hashtag.lstrip("#")
+ if self.name_override:
+ self.name_override = self.name_override.lstrip("#")
+ return super().save(*args, **kwargs)
+
+ @property
+ def display_name(self):
+ return self.name_override or self.hashtag
+
+ def __str__(self):
+ return self.display_name
+
+ def usage_months(self, num: int = 12) -> dict[date, int]:
+ """
+ Return the most recent num months of stats
+ """
+ if not self.stats:
+ return {}
+ results = {}
+ for key, val in self.stats.items():
+ parts = key.split("-")
+ if len(parts) == 2:
+ year = int(parts[0])
+ month = int(parts[1])
+ results[date(year, month, 1)] = val
+ return dict(sorted(results.items(), reverse=True)[:num])
+
+ def usage_days(self, num: int = 7) -> dict[date, int]:
+ """
+ Return the most recent num days of stats
+ """
+ if not self.stats:
+ return {}
+ results = {}
+ for key, val in self.stats.items():
+ parts = key.split("-")
+ if len(parts) == 3:
+ year = int(parts[0])
+ month = int(parts[1])
+ day = int(parts[2])
+ results[date(year, month, day)] = val
+ return dict(sorted(results.items(), reverse=True)[:num])
+
+ def to_mastodon_json(self, following: bool | None = None):
+ value = {
+ "name": self.hashtag,
+ "url": self.urls.view.full(), # type: ignore
+ "history": [],
+ }
+
+ if following is not None:
+ value["following"] = following
+
+ return value
+
+
+class PostInteraction(models.Model):
+ """
+ Handles both boosts and likes
+ """
+
+ class Types(models.TextChoices):
+ like = "like"
+ boost = "boost"
+ vote = "vote"
+ pin = "pin"
+
+ id = models.BigIntegerField(
+ primary_key=True,
+ default=Snowflake.generate_post_interaction,
+ )
+
+ # The state the boost is in
+ # state = StateField(PostInteractionStates)
+ state = models.CharField(max_length=100, default="new")
+ state_changed = models.DateTimeField(auto_now_add=True)
+
+ # The canonical object ID
+ object_uri = models.CharField(max_length=500, blank=True, null=True, unique=True)
+
+ # What type of interaction it is
+ type = models.CharField(max_length=100, choices=Types.choices)
+
+ # The user who boosted/liked/etc.
+ identity = models.ForeignKey(
+ "takahe.Identity",
+ on_delete=models.CASCADE,
+ related_name="interactions",
+ )
+
+ # The post that was boosted/liked/etc
+ post = models.ForeignKey(
+ "takahe.Post",
+ on_delete=models.CASCADE,
+ related_name="interactions",
+ )
+
+ # Used to store any interaction extra text value like the vote
+ # in the question/poll case
+ value = models.CharField(max_length=50, blank=True, null=True)
+
+ # When the activity was originally created (as opposed to when we received it)
+ # Mastodon only seems to send this for boosts, not likes
+ published = models.DateTimeField(default=timezone.now)
+
+ created = models.DateTimeField(auto_now_add=True)
+ updated = models.DateTimeField(auto_now=True)
+
+ class Meta:
+ # managed = False
+ db_table = "activities_postinteraction"
+
+
+class Block(models.Model):
+ """
+ When one user (the source) mutes or blocks another (the target)
+ """
+
+ # state = StateField(BlockStates)
+ state = models.CharField(max_length=100, default="new")
+ state_changed = models.DateTimeField(auto_now_add=True)
+
+ source = models.ForeignKey(
+ "takahe.Identity",
+ on_delete=models.CASCADE,
+ related_name="outbound_blocks",
+ )
+
+ target = models.ForeignKey(
+ "takahe.Identity",
+ on_delete=models.CASCADE,
+ related_name="inbound_blocks",
+ )
+
+ uri = models.CharField(blank=True, null=True, max_length=500)
+
+ # If it is a mute, we will stop delivering any activities from target to
+ # source, but we will still deliver activities from source to target.
+ # A full block (mute=False) stops activities both ways.
+ mute = models.BooleanField()
+ include_notifications = models.BooleanField(default=False)
+
+ expires = models.DateTimeField(blank=True, null=True)
+ note = models.TextField(blank=True, null=True)
+
+ created = models.DateTimeField(auto_now_add=True)
+ updated = models.DateTimeField(auto_now=True)
+
+ class Meta:
+ # managed = False
+ db_table = "users_block"
+
+ def __str__(self):
+ return f"#{self.pk}: {self.source} blocks {self.target}"
+
+ ### Alternate fetchers/constructors ###
+
+ @classmethod
+ def maybe_get(
+ cls, source, target, mute=False, require_active=False
+ ) -> Optional["Block"]:
+ """
+ Returns a Block if it exists between source and target
+ """
+ try:
+ if require_active:
+ return cls.objects.filter(
+ status__in=["new", "sent", "awaiting_expiry"]
+ ).get(source=source, target=target, mute=mute)
+ else:
+ return cls.objects.get(source=source, target=target, mute=mute)
+ except cls.DoesNotExist:
+ return None
+
+ @classmethod
+ def create_local_block(cls, source, target) -> "Block":
+ """
+ Creates or updates a full Block from a local Identity to the target
+ (which can be local or remote).
+ """
+ if not source.local:
+ raise ValueError("You cannot block from a remote Identity")
+ block = cls.maybe_get(source=source, target=target, mute=False)
+ if block is not None:
+ if not block.state in ["new", "sent", "awaiting_expiry"]:
+ block.state = BlockStates.new # type:ignore
+ block.save()
+ else:
+ with transaction.atomic():
+ block = cls.objects.create(
+ source=source,
+ target=target,
+ mute=False,
+ )
+ block.uri = source.actor_uri + f"block/{block.pk}/"
+ block.save()
+ return block
+
+ @classmethod
+ def create_local_mute(
+ cls,
+ source,
+ target,
+ duration=None,
+ include_notifications=False,
+ ) -> "Block":
+ """
+ Creates or updates a muting Block from a local Identity to the target
+ (which can be local or remote).
+ """
+ if not source.local:
+ raise ValueError("You cannot mute from a remote Identity")
+ block = cls.maybe_get(source=source, target=target, mute=True)
+ if block is not None:
+ if not block in ["new", "sent", "awaiting_expiry"]:
+ block.state = BlockStates.new # type:ignore
+ if duration:
+ block.expires = timezone.now() + datetime.timedelta(seconds=duration)
+ block.include_notifications = include_notifications
+ block.save()
+ else:
+ with transaction.atomic():
+ block = cls.objects.create(
+ source=source,
+ target=target,
+ mute=True,
+ include_notifications=include_notifications,
+ expires=(
+ timezone.now() + datetime.timedelta(seconds=duration)
+ if duration
+ else None
+ ),
+ )
+ block.uri = source.actor_uri + f"block/{block.pk}/"
+ block.save()
+ return block
diff --git a/takahe/tests.py b/takahe/tests.py
new file mode 100644
index 00000000..7ce503c2
--- /dev/null
+++ b/takahe/tests.py
@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.
diff --git a/takahe/uris.py b/takahe/uris.py
new file mode 100644
index 00000000..e686108b
--- /dev/null
+++ b/takahe/uris.py
@@ -0,0 +1,89 @@
+import hashlib
+import sys
+from urllib.parse import urljoin
+
+from django.conf import settings
+from django.contrib.staticfiles.storage import staticfiles_storage
+
+
+class RelativeAbsoluteUrl:
+ """
+ Represents a URL that can have both "relative" and "absolute" forms
+ for various use either locally or remotely.
+ """
+
+ absolute: str
+ relative: str
+
+ def __init__(self, absolute: str, relative: str | None = None):
+ if "://" not in absolute:
+ raise ValueError(f"Absolute URL {absolute!r} is not absolute!")
+ self.absolute = absolute
+ self.relative = relative or absolute
+
+
+class AutoAbsoluteUrl(RelativeAbsoluteUrl):
+ """
+ Automatically makes the absolute variant by using either settings.MAIN_DOMAIN
+ or a passed identity's URI domain.
+ """
+
+ def __init__(
+ self,
+ relative: str,
+ identity=None,
+ ):
+ self.relative = relative
+ if identity:
+ absolute_prefix = f"https://{identity.domain.uri_domain}/"
+ else:
+ absolute_prefix = f"https://{settings.MAIN_DOMAIN}/"
+ self.absolute = urljoin(absolute_prefix, self.relative)
+
+
+class ProxyAbsoluteUrl(AutoAbsoluteUrl):
+ """
+ AutoAbsoluteUrl variant for proxy paths, that also attaches a remote URI hash
+ plus extension to the end if it can.
+ """
+
+ def __init__(
+ self,
+ relative: str,
+ identity=None,
+ remote_url: str | None = None,
+ ):
+ if remote_url:
+ # See if there is a file extension we can grab
+ extension = "bin"
+ remote_filename = remote_url.split("/")[-1]
+ if "." in remote_filename:
+ extension = remote_filename.split(".")[-1]
+ # When provided, attach a hash of the remote URL
+ # SHA1 chosen as it generally has the best performance in modern python, and security is not a concern
+ # Hash truncation is generally fine, as in the typical use case the hash is scoped to the identity PK.
+ relative += f"{hashlib.sha1(remote_url.encode('ascii')).hexdigest()[:10]}.{extension}"
+ super().__init__(relative, identity)
+
+
+class StaticAbsoluteUrl(RelativeAbsoluteUrl):
+ """
+ Creates static URLs given only the static-relative path
+ """
+
+ def __init__(self, path: str):
+ try:
+ static_url = staticfiles_storage.url(path)
+ except ValueError:
+ # Suppress static issues during the first collectstatic
+ # Yes, I know it's a big hack! Pull requests welcome :)
+ if "collectstatic" in sys.argv:
+ super().__init__("https://example.com/")
+ return
+ raise
+ if "://" in static_url:
+ super().__init__(static_url)
+ else:
+ super().__init__(
+ urljoin(f"https://{settings.MAIN_DOMAIN}/", static_url), static_url
+ )
diff --git a/takahe/utils.py b/takahe/utils.py
new file mode 100644
index 00000000..f8498b9d
--- /dev/null
+++ b/takahe/utils.py
@@ -0,0 +1,486 @@
+from typing import TYPE_CHECKING
+
+from django.conf import settings
+
+from .models import *
+
+if TYPE_CHECKING:
+ from users.models import APIdentity
+ from users.models import User as NeoUser
+
+
+def _int(s: str):
+ try:
+ return int(s)
+ except:
+ return -1
+
+
+def _rating_to_emoji(score: int, star_mode=0):
+ """convert score(0~10) to mastodon star emoji code"""
+ if score is None or score == "" or score == 0:
+ return ""
+ solid_stars = score // 2
+ half_star = int(bool(score % 2))
+ empty_stars = 5 - solid_stars if not half_star else 5 - solid_stars - 1
+ if star_mode == 1:
+ emoji_code = "🌕" * solid_stars + "🌗" * half_star + "🌑" * empty_stars
+ else:
+ emoji_code = (
+ settings.STAR_SOLID * solid_stars
+ + settings.STAR_HALF * half_star
+ + settings.STAR_EMPTY * empty_stars
+ )
+ emoji_code = emoji_code.replace("::", ": :")
+ emoji_code = " " + emoji_code + " "
+ return emoji_code
+
+
+class Takahe:
+ Visibilities = Post.Visibilities
+
+ @staticmethod
+ def get_domain():
+ domain = settings.SITE_INFO["site_domain"]
+ d = Domain.objects.filter(domain=domain).first()
+ if not d:
+ logger.info(f"Creating takahe domain {domain}")
+ d = Domain.objects.create(
+ domain=domain,
+ local=True,
+ service_domain=None,
+ notes="NeoDB",
+ nodeinfo=None,
+ )
+ return d
+
+ @staticmethod
+ def get_node_name_for_domain(d: str):
+ domain = Domain.objects.filter(domain=d).first()
+ if domain and domain.nodeinfo:
+ return domain.nodeinfo.get("metadata", {}).get("nodeName")
+
+ @staticmethod
+ def init_identity_for_local_user(u: "NeoUser"):
+ """
+ When a new local NeoDB user is created,
+ create a takahe user with the NeoDB user pk,
+ create a takahe identity,
+ then create a NeoDB APIdentity with the takahe identity pk.
+ """
+ from users.models import APIdentity
+
+ if not u.username:
+ logger.warning(f"User {u} has no username")
+ return None
+ user = User.objects.filter(pk=u.pk).first()
+ handler = "@" + u.username
+ if not user:
+ logger.info(f"Creating takahe user {u}")
+ user = User.objects.create(pk=u.pk, email=handler)
+ else:
+ if user.email != handler:
+ logger.warning(f"Updating takahe user {u} email to {handler}")
+ user.email = handler
+ user.save()
+ domain = Domain.objects.get(domain=settings.SITE_INFO["site_domain"])
+ identity = Identity.objects.filter(username=u.username, local=True).first()
+ if not identity:
+ logger.info(f"Creating takahe identity {u}@{domain}")
+ identity = Identity.objects.create(
+ actor_uri=f"https://{domain.uri_domain}/@{u.username}@{domain.domain}/",
+ username=u.username,
+ domain=domain,
+ name=u.username,
+ local=True,
+ discoverable=not u.preference.no_anonymous_view,
+ )
+ identity.generate_keypair()
+ if not user.identities.filter(pk=identity.pk).exists():
+ user.identities.add(identity)
+ apidentity = APIdentity.objects.filter(pk=identity.pk).first()
+ if not apidentity:
+ logger.info(f"Creating APIdentity for {identity}")
+ apidentity = APIdentity.objects.create(
+ user=u,
+ id=identity.pk,
+ local=True,
+ username=u.username,
+ domain_name=domain.domain,
+ deleted=identity.deleted,
+ )
+ elif apidentity.username != identity.username:
+ logger.warning(
+ f"Updating APIdentity {apidentity} username to {identity.username}"
+ )
+ apidentity.username = identity.username
+ apidentity.save()
+ if u.identity != apidentity:
+ logger.warning(f"Linking user {u} identity to {apidentity}")
+ u.identity = apidentity
+ u.save(update_fields=["identity"])
+ return apidentity
+
+ @staticmethod
+ def get_identity(pk: int):
+ return Identity.objects.get(pk=pk)
+
+ @staticmethod
+ def get_identity_by_local_user(u: "NeoUser"):
+ return (
+ Identity.objects.filter(pk=u.identity.pk, local=True).first()
+ if u and u.is_authenticated and u.identity
+ else None
+ )
+
+ @staticmethod
+ def get_or_create_apidentity(identity: Identity):
+ from users.models import APIdentity
+
+ apid = APIdentity.objects.filter(pk=identity.pk).first()
+ if not apid:
+ if identity.local:
+ raise ValueError(f"local takahe identity {identity} missing APIdentity")
+ if not identity.domain:
+ raise ValueError(f"remote takahe identity {identity} missing domain")
+ apid = APIdentity.objects.create(
+ id=identity.pk,
+ local=False,
+ username=identity.username,
+ domain_name=identity.domain.domain,
+ deleted=identity.deleted,
+ )
+ return apid
+
+ @staticmethod
+ def get_local_user_by_identity(identity: Identity):
+ from users.models import User as NeoUser
+
+ return NeoUser.objects.get(identity_id=identity.pk) if identity.local else None
+
+ @staticmethod
+ def get_following_ids(identity_pk: int):
+ targets = Follow.objects.filter(
+ source_id=identity_pk, state="accepted"
+ ).values_list("target", flat=True)
+ return list(targets)
+
+ @staticmethod
+ def get_follower_ids(identity_pk: int):
+ targets = Follow.objects.filter(
+ target_id=identity_pk, state="accepted"
+ ).values_list("target", flat=True)
+ return list(targets)
+
+ @staticmethod
+ def get_following_request_ids(identity_pk: int):
+ targets = Follow.objects.filter(
+ source_id=identity_pk, state="pending_approval"
+ ).values_list("target", flat=True)
+ return list(targets)
+
+ @staticmethod
+ def get_requested_follower_ids(identity_pk: int):
+ targets = Follow.objects.filter(
+ target_id=identity_pk, state="pending_approval"
+ ).values_list("target", flat=True)
+ return list(targets)
+
+ @staticmethod
+ def update_follow_state(
+ source_pk: int, target_pk: int, from_states: list[str], to_state: str
+ ):
+ follow = Follow.objects.filter(source_id=source_pk, target_id=target_pk).first()
+ if (
+ follow
+ and (not from_states or follow.state in from_states)
+ and follow.state != to_state
+ ):
+ follow.state = to_state
+ follow.save()
+ return follow
+
+ @staticmethod
+ def follow(source_pk: int, target_pk: int):
+ try:
+ follow = Follow.objects.get(source_id=source_pk, target_id=target_pk)
+ if follow.state != "accepted":
+ follow.state = "unrequested"
+ follow.save()
+ except Follow.DoesNotExist:
+ source = Identity.objects.get(pk=source_pk)
+ follow = Follow.objects.create(
+ source_id=source_pk,
+ target_id=target_pk,
+ boosts=True,
+ uri="",
+ state="unrequested",
+ )
+ follow.uri = source.actor_uri + f"follow/{follow.pk}/"
+ follow.save()
+
+ @staticmethod
+ def unfollow(source_pk: int, target_pk: int):
+ Takahe.update_follow_state(source_pk, target_pk, [], "undone")
+ # InboxMessage.create_internal(
+ # {
+ # "type": "ClearTimeline",
+ # "object": target_identity.pk,
+ # "actor": self.identity.pk,
+ # }
+ # )
+
+ @staticmethod
+ def accept_follow_request(source_pk: int, target_pk: int):
+ Takahe.update_follow_state(source_pk, target_pk, [], "accepting")
+
+ @staticmethod
+ def reject_follow_request(source_pk: int, target_pk: int):
+ Takahe.update_follow_state(source_pk, target_pk, [], "rejecting")
+
+ @staticmethod
+ def get_muting_ids(identity_pk: int) -> list[int]:
+ targets = Block.objects.filter(
+ source_id=identity_pk,
+ mute=True,
+ state__in=["new", "sent", "awaiting_expiry"],
+ ).values_list("target", flat=True)
+ return list(targets)
+
+ @staticmethod
+ def get_blocking_ids(identity_pk: int) -> list[int]:
+ targets = Block.objects.filter(
+ source_id=identity_pk,
+ mute=False,
+ state__in=["new", "sent", "awaiting_expiry"],
+ ).values_list("target", flat=True)
+ return list(targets)
+
+ @staticmethod
+ def get_rejecting_ids(identity_pk: int) -> list[int]:
+ pks1 = Block.objects.filter(
+ source_id=identity_pk,
+ mute=False,
+ state__in=["new", "sent", "awaiting_expiry"],
+ ).values_list("target", flat=True)
+ pks2 = Block.objects.filter(
+ target_id=identity_pk,
+ mute=False,
+ state__in=["new", "sent", "awaiting_expiry"],
+ ).values_list("source", flat=True)
+ return list(set(list(pks1) + list(pks2)))
+
+ @staticmethod
+ def block_or_mute(source_pk: int, target_pk: int, is_mute: bool):
+ source = Identity.objects.get(pk=source_pk)
+ if not source.local:
+ raise ValueError(f"Cannot block/mute from remote identity {source}")
+ with transaction.atomic():
+ block, _ = Block.objects.update_or_create(
+ defaults={"state": "new"},
+ source_id=source_pk,
+ target_id=target_pk,
+ mute=is_mute,
+ )
+ if block.state != "new" or not block.uri:
+ block.state = "new"
+ block.uri = source.actor_uri + f"block/{block.pk}/"
+ block.save()
+ if not is_mute:
+ Takahe.unfollow(source_pk, target_pk)
+ Takahe.reject_follow_request(target_pk, source_pk)
+ return block
+
+ @staticmethod
+ def undo_block_or_mute(source_pk: int, target_pk: int, is_mute: bool):
+ Block.objects.filter(
+ source_id=source_pk, target_id=target_pk, mute=is_mute
+ ).update(state="undone")
+
+ @staticmethod
+ def block(source_pk: int, target_pk: int):
+ return Takahe.block_or_mute(source_pk, target_pk, False)
+
+ @staticmethod
+ def unblock(source_pk: int, target_pk: int):
+ return Takahe.undo_block_or_mute(source_pk, target_pk, False)
+
+ @staticmethod
+ def mute(source_pk: int, target_pk: int):
+ return Takahe.block_or_mute(source_pk, target_pk, True)
+
+ @staticmethod
+ def unmute(source_pk: int, target_pk: int):
+ return Takahe.undo_block_or_mute(source_pk, target_pk, True)
+
+ @staticmethod
+ def _force_state_cycle(): # for unit testing only
+ Follow.objects.filter(
+ state__in=["rejecting", "undone", "pending_removal"]
+ ).delete()
+ Follow.objects.all().update(state="accepted")
+ Block.objects.filter(state="new").update(state="sent")
+ Block.objects.exclude(state="sent").delete()
+
+ @staticmethod
+ def post(
+ author_pk: int,
+ pre_conetent: str,
+ content: str,
+ visibility: Visibilities,
+ data: dict | None = None,
+ post_pk: int | None = None,
+ post_time: datetime.datetime | None = None,
+ ) -> int | None:
+ identity = Identity.objects.get(pk=author_pk)
+ post = (
+ Post.objects.filter(author=identity, pk=post_pk).first()
+ if post_pk
+ else None
+ )
+ if post:
+ post.edit_local(
+ pre_conetent, content, visibility=visibility, type_data=data
+ )
+ else:
+ post = Post.create_local(
+ identity,
+ pre_conetent,
+ content,
+ visibility=visibility,
+ type_data=data,
+ published=post_time,
+ )
+ return post.pk if post else None
+
+ @staticmethod
+ def get_post_url(post_pk: int) -> str | None:
+ post = Post.objects.filter(pk=post_pk).first() if post_pk else None
+ return post.object_uri if post else None
+
+ @staticmethod
+ def delete_mark(mark):
+ if mark.shelfmember and mark.shelfmember.post_id:
+ Post.objects.filter(pk=mark.shelfmember.post_id).update(state="deleted")
+
+ @staticmethod
+ def post_mark(mark, share_as_new_post: bool):
+ from catalog.common import ItemCategory
+ from takahe.utils import Takahe
+
+ user = mark.owner.user
+ tags = (
+ "\n"
+ + user.preference.mastodon_append_tag.replace(
+ "[category]", str(ItemCategory(mark.item.category).label)
+ )
+ if user.preference.mastodon_append_tag
+ else ""
+ )
+ stars = _rating_to_emoji(mark.rating_grade, 0)
+ item_link = f"{settings.SITE_INFO['site_url']}/~neodb~{mark.item.url}"
+
+ pre_conetent = (
+ f'{mark.action_label}《{mark.item.display_title}》'
+ )
+ content = f"{stars}\n{mark.comment_text or ''}{tags}"
+ data = {
+ "object": {
+ "relatedWith": [mark.item.ap_object_ref, mark.shelfmember.ap_object]
+ }
+ }
+ if mark.comment:
+ data["object"]["relatedWith"].append(mark.comment.ap_object)
+ if mark.rating:
+ data["object"]["relatedWith"].append(mark.rating.ap_object)
+ if mark.visibility == 1:
+ v = Takahe.Visibilities.followers
+ elif mark.visibility == 2:
+ v = Takahe.Visibilities.mentioned
+ elif user.preference.mastodon_publish_public:
+ v = Takahe.Visibilities.public
+ else:
+ v = Takahe.Visibilities.unlisted
+ post_pk = Takahe.post(
+ mark.owner.pk,
+ pre_conetent,
+ content,
+ v,
+ data,
+ None if share_as_new_post else mark.shelfmember.post_id,
+ mark.shelfmember.created_time,
+ )
+ if post_pk != mark.shelfmember.post_id:
+ mark.shelfmember.post_id = post_pk
+ mark.shelfmember.save(update_fields=["post_id"])
+ if mark.comment and post_pk != mark.comment.post_id:
+ mark.comment.post_id = post_pk
+ mark.comment.save(update_fields=["post_id"])
+ if mark.rating and post_pk != mark.rating.post_id:
+ mark.rating.post_id = post_pk
+ mark.rating.save(update_fields=["post_id"])
+
+ @staticmethod
+ def interact_post(post_pk: int, identity_pk: int, type: str):
+ post = Post.objects.filter(pk=post_pk).first()
+ if not post:
+ logger.warning(f"Cannot find post {post_pk}")
+ return
+ interaction = PostInteraction.objects.get_or_create(
+ type=type,
+ identity_id=identity_pk,
+ post=post,
+ )[0]
+ if interaction.state not in ["new", "fanned_out"]:
+ interaction.state = "new"
+ interaction.save()
+ post.calculate_stats()
+ return interaction
+
+ @staticmethod
+ def uninteract_post(post_pk: int, identity_pk: int, type: str):
+ post = Post.objects.filter(pk=post_pk).first()
+ if not post:
+ logger.warning(f"Cannot find post {post_pk}")
+ return
+ for interaction in PostInteraction.objects.filter(
+ type=type,
+ identity_id=identity_pk,
+ post=post,
+ ):
+ interaction.state = "undone"
+ interaction.save()
+ post.calculate_stats()
+
+ @staticmethod
+ def like_post(post_pk: int, identity_pk: int):
+ return Takahe.interact_post(post_pk, identity_pk, "like")
+
+ @staticmethod
+ def unlike_post(post_pk: int, identity_pk: int):
+ return Takahe.uninteract_post(post_pk, identity_pk, "like")
+
+ @staticmethod
+ def post_liked_by(post_pk: int, identity_pk: int) -> bool:
+ interaction = Takahe.get_user_interaction(post_pk, identity_pk, "like")
+ return interaction is not None and interaction.state in ["new", "fanned_out"]
+
+ @staticmethod
+ def get_user_interaction(post_pk: int, identity_pk: int, type: str):
+ post = Post.objects.filter(pk=post_pk).first()
+ if not post:
+ logger.warning(f"Cannot find post {post_pk}")
+ return None
+ return PostInteraction.objects.filter(
+ type=type,
+ identity_id=identity_pk,
+ post=post,
+ ).first()
+
+ @staticmethod
+ def get_post_stats(post_pk: int) -> dict:
+ post = Post.objects.filter(pk=post_pk).first()
+ if not post:
+ logger.warning(f"Cannot find post {post_pk}")
+ return {}
+ return post.stats or {}
diff --git a/takahe/views.py b/takahe/views.py
new file mode 100644
index 00000000..91ea44a2
--- /dev/null
+++ b/takahe/views.py
@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.
diff --git a/users/account.py b/users/account.py
index 1f6499bb..5a6c1eb4 100644
--- a/users/account.py
+++ b/users/account.py
@@ -396,6 +396,7 @@ def register(request):
)
messages.add_message(request, messages.INFO, _("已发送验证邮件，请查收。"))
if username_changed:
+ request.user.initiatialize()
messages.add_message(request, messages.INFO, _("用户名已设置。"))
if email_cleared:
messages.add_message(request, messages.INFO, _("电子邮件地址已取消关联。"))
@@ -480,9 +481,9 @@ def auth_logout(request):
def clear_data_task(user_id):
user = User.objects.get(pk=user_id)
user_str = str(user)
- remove_data_by_user(user)
+ if user.identity:
+ remove_data_by_user(user.identity)
user.clear()
- user.save()
logger.warning(f"User {user_str} data cleared.")
diff --git a/users/management/commands/refresh_following.py b/users/management/commands/refresh_following.py
deleted file mode 100644
index c57329d2..00000000
--- a/users/management/commands/refresh_following.py
+++ /dev/null
@@ -1,21 +0,0 @@
-from datetime import timedelta
-
-from django.core.management.base import BaseCommand
-from django.utils import timezone
-from tqdm import tqdm
-
-from users.models import User
-
-
-class Command(BaseCommand):
- help = "Refresh following data for all users"
-
- def handle(self, *args, **options):
- count = 0
- for user in tqdm(User.objects.all()):
- user.following = user.merged_following_ids()
- if user.following:
- count += 1
- user.save(update_fields=["following"])
-
- print(f"{count} users updated")
diff --git a/users/migrations/0012_apidentity.py b/users/migrations/0012_apidentity.py
new file mode 100644
index 00000000..ab04b30e
--- /dev/null
+++ b/users/migrations/0012_apidentity.py
@@ -0,0 +1,63 @@
+# Generated by Django 4.2.4 on 2023-08-09 13:37
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ # replaces = [
+ # ("users", "0012_user_local"),
+ # ("users", "0013_user_identity"),
+ # ("users", "0014_remove_user_identity_apidentity_user"),
+ # ("users", "0015_alter_apidentity_user"),
+ # ]
+
+ dependencies = [
+ ("users", "0011_preference_hidden_categories"),
+ ("takahe", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="APIdentity",
+ fields=[
+ (
+ "id",
+ models.BigAutoField(
+ auto_created=True,
+ primary_key=True,
+ serialize=False,
+ verbose_name="ID",
+ ),
+ ),
+ ("local", models.BooleanField()),
+ ("username", models.CharField(blank=True, max_length=500, null=True)),
+ (
+ "domain_name",
+ models.CharField(blank=True, max_length=500, null=True),
+ ),
+ ("deleted", models.DateTimeField(blank=True, null=True)),
+ (
+ "user",
+ models.OneToOneField(
+ on_delete=django.db.models.deletion.CASCADE,
+ related_name="identity",
+ to=settings.AUTH_USER_MODEL,
+ ),
+ ),
+ ],
+ options={
+ "indexes": [
+ models.Index(
+ fields=["local", "username"],
+ name="users_apide_local_2d8170_idx",
+ ),
+ models.Index(
+ fields=["domain_name", "username"],
+ name="users_apide_domain__53ffa5_idx",
+ ),
+ ],
+ },
+ ),
+ ]
diff --git a/users/migrations/0013_init_identity.py b/users/migrations/0013_init_identity.py
new file mode 100644
index 00000000..551faeee
--- /dev/null
+++ b/users/migrations/0013_init_identity.py
@@ -0,0 +1,77 @@
+# Generated by Django 4.2.4 on 2023-08-09 16:54
+
+from django.conf import settings
+from django.db import migrations, models, transaction
+from loguru import logger
+from tqdm import tqdm
+
+from takahe.models import Domain as TakaheDomain
+from takahe.models import Identity as TakaheIdentity
+from takahe.models import User as TakaheUser
+
+domain = settings.SITE_INFO["site_domain"]
+service_domain = settings.SITE_INFO.get("site_service_domain")
+
+
+def init_domain(apps, schema_editor):
+ d = TakaheDomain.objects.filter(domain=domain).first()
+ if not d:
+ logger.info(f"Creating takahe domain {domain}")
+ TakaheDomain.objects.create(
+ domain=domain,
+ local=True,
+ service_domain=service_domain,
+ notes="NeoDB",
+ nodeinfo={},
+ )
+ else:
+ logger.info(f"Takahe domain {domain} already exists")
+
+
+def init_identity(apps, schema_editor):
+ User = apps.get_model("users", "User")
+ APIdentity = apps.get_model("users", "APIdentity")
+ tdomain = TakaheDomain.objects.filter(domain=domain).first()
+ if User.objects.filter(username__isnull=True).exists():
+ raise ValueError("null username detected, aborting migration")
+ if TakaheUser.objects.exists():
+ raise ValueError("existing Takahe users detected, aborting migration")
+ if TakaheIdentity.objects.exists():
+ raise ValueError("existing Takahe identities detected, aborting migration")
+ if APIdentity.objects.exists():
+ raise ValueError("existing APIdentity data detected, aborting migration")
+ logger.info(f"Creating takahe users/identities")
+ for user in tqdm(User.objects.all()):
+ username = user.username
+ handler = "@" + username
+ identity = APIdentity.objects.create(
+ pk=user.pk,
+ user=user,
+ local=True,
+ username=username,
+ domain_name=domain,
+ deleted=None if user.is_active else user.updated,
+ )
+ takahe_user = TakaheUser.objects.create(pk=user.pk, email=handler)
+ takahe_identity = TakaheIdentity.objects.create(
+ pk=user.pk,
+ actor_uri=f"https://{service_domain or domain}/@{username}@{domain}/",
+ username=username,
+ domain=tdomain,
+ name=username,
+ local=True,
+ discoverable=not user.preference.no_anonymous_view,
+ )
+ takahe_user.identities.add(takahe_identity)
+
+
+class Migration(migrations.Migration):
+
+ dependencies = [
+ ("users", "0012_apidentity"),
+ ]
+
+ operations = [
+ migrations.RunPython(init_domain),
+ migrations.RunPython(init_identity),
+ ]
diff --git a/users/models/__init__.py b/users/models/__init__.py
index d1e45854..14d42a2e 100644
--- a/users/models/__init__.py
+++ b/users/models/__init__.py
@@ -1,3 +1,4 @@
+from .apidentity import APIdentity
from .preference import Preference
from .report import Report
from .user import User
diff --git a/users/models/apidentity.py b/users/models/apidentity.py
new file mode 100644
index 00000000..a22c68d2
--- /dev/null
+++ b/users/models/apidentity.py
@@ -0,0 +1,192 @@
+from functools import cached_property
+
+from django.conf import settings
+from django.db import models
+from loguru import logger
+
+from takahe.utils import Takahe
+
+from .user import User
+
+
+class APIdentity(models.Model):
+ """
+ An identity/actor in ActivityPub service.
+
+ This model is used as 1:1 mapping to Takahe Identity Model
+ """
+
+ user = models.OneToOneField("User", models.CASCADE, related_name="identity")
+ local = models.BooleanField()
+ username = models.CharField(max_length=500, blank=True, null=True)
+ domain_name = models.CharField(max_length=500, blank=True, null=True)
+ deleted = models.DateTimeField(null=True, blank=True)
+
+ class Meta:
+ indexes = [
+ models.Index(fields=["local", "username"]),
+ models.Index(fields=["domain_name", "username"]),
+ ]
+
+ @cached_property
+ def takahe_identity(self):
+ return Takahe.get_identity(self.pk)
+
+ @property
+ def is_active(self):
+ return self.user.is_active and self.takahe_identity.deleted is None
+
+ @property
+ def name(self):
+ return self.takahe_identity.name
+
+ @property
+ def discoverable(self):
+ return self.takahe_identity.discoverable
+
+ @property
+ def actor_uri(self):
+ return self.takahe_identity.actor_uri
+
+ @property
+ def icon_uri(self):
+ return self.takahe_identity.icon_uri
+
+ @property
+ def display_name(self):
+ return self.takahe_identity.name
+
+ @property
+ def avatar(self):
+ return self.user.avatar # FiXME
+
+ @property
+ def url(self):
+ return f"/users/{self.handler}/"
+
+ @property
+ def preference(self):
+ return self.user.preference
+
+ @property
+ def handler(self):
+ if self.local:
+ return self.username
+ else:
+ return f"{self.username}@{self.domain_name}"
+
+ @property
+ def following(self):
+ return Takahe.get_following_ids(self.pk)
+
+ @property
+ def muting(self):
+ return Takahe.get_muting_ids(self.pk)
+
+ @property
+ def blocking(self):
+ return Takahe.get_blocking_ids(self.pk)
+
+ @property
+ def rejecting(self):
+ return Takahe.get_rejecting_ids(self.pk)
+
+ @property
+ def ignoring(self):
+ return self.muting + self.rejecting
+
+ def follow(self, target: "APIdentity"):
+ Takahe.follow(self.pk, target.pk)
+
+ def unfollow(self, target: "APIdentity"): # this also cancels follow request
+ Takahe.unfollow(self.pk, target.pk)
+
+ def requested_followers(self):
+ Takahe.get_requested_follower_ids(self.pk)
+
+ def following_request(self):
+ Takahe.get_following_request_ids(self.pk)
+
+ def accept_follow_request(self, target: "APIdentity"):
+ Takahe.accept_follow_request(self.pk, target.pk)
+
+ def reject_follow_request(self, target: "APIdentity"):
+ Takahe.reject_follow_request(self.pk, target.pk)
+
+ def block(self, target: "APIdentity"):
+ Takahe.block(self.pk, target.pk)
+
+ def unblock(self, target: "APIdentity"):
+ Takahe.unblock(self.pk, target.pk)
+
+ def mute(self, target: "APIdentity"):
+ Takahe.mute(self.pk, target.pk)
+
+ def unmute(self, target: "APIdentity"):
+ Takahe.unmute(self.pk, target.pk)
+
+ def is_rejecting(self, target: "APIdentity"):
+ return self != target and (
+ target.is_blocked_by(self) or target.is_blocking(self)
+ )
+
+ def is_blocking(self, target: "APIdentity"):
+ return target.pk in self.blocking
+
+ def is_blocked_by(self, target: "APIdentity"):
+ return target.is_blocking(self)
+
+ def is_muting(self, target: "APIdentity"):
+ return target.pk in self.muting
+
+ def is_following(self, target: "APIdentity"):
+ return target.pk in self.following
+
+ def is_followed_by(self, target: "APIdentity"):
+ return target.is_following(self)
+
+ def is_visible_to_user(self, viewing_user: User):
+ return (
+ viewing_user.is_authenticated
+ or viewing_user == self.user
+ or (
+ not self.is_blocking(viewing_user.identity)
+ and not self.is_blocked_by(viewing_user.identity)
+ )
+ )
+
+ @classmethod
+ def get_by_handler(cls, handler: str) -> "APIdentity":
+ s = handler.split("@")
+ if len(s) == 1:
+ return cls.objects.get(username=s[0], local=True, deleted__isnull=True)
+ elif len(s) == 2:
+ return cls.objects.get(
+ user__mastodon_username=s[0],
+ user__mastodon_site=s[1],
+ deleted__isnull=True,
+ )
+ elif len(s) == 3 and s[0] == "":
+ return cls.objects.get(
+ username=s[0], domain_name=s[1], local=False, deleted__isnull=True
+ )
+ else:
+ raise cls.DoesNotExist(f"Invalid handler {handler}")
+
+ @cached_property
+ def activity_manager(self):
+ from social.models import ActivityManager
+
+ return ActivityManager(self)
+
+ @cached_property
+ def shelf_manager(self):
+ from journal.models import ShelfManager
+
+ return ShelfManager(self)
+
+ @cached_property
+ def tag_manager(self):
+ from journal.models import TagManager
+
+ return TagManager(self)
diff --git a/users/models/preference.py b/users/models/preference.py
index 6cc96ef9..ac5a0b45 100644
--- a/users/models/preference.py
+++ b/users/models/preference.py
@@ -20,6 +20,7 @@ from loguru import logger
from common.utils import GenerateDateUUIDMediaFilePath
from management.models import Announcement
from mastodon.api import *
+from takahe.utils import Takahe
from .user import User
diff --git a/users/models/report.py b/users/models/report.py
index caabd49c..4a65d2a2 100644
--- a/users/models/report.py
+++ b/users/models/report.py
@@ -1,24 +1,9 @@
-import hashlib
-import re
-from functools import cached_property
-
from django.conf import settings
-from django.contrib.auth.models import AbstractUser
-from django.core import validators
-from django.core.exceptions import ValidationError
-from django.core.serializers.json import DjangoJSONEncoder
from django.db import models
-from django.db.models import F, Q, Value
-from django.db.models.functions import Concat, Lower
-from django.templatetags.static import static
-from django.urls import reverse
-from django.utils import timezone
-from django.utils.deconstruct import deconstructible
from django.utils.translation import gettext_lazy as _
from loguru import logger
from common.utils import GenerateDateUUIDMediaFilePath
-from management.models import Announcement
from mastodon.api import *
from .user import User
diff --git a/users/models/user.py b/users/models/user.py
index 7f77db0c..68a8c322 100644
--- a/users/models/user.py
+++ b/users/models/user.py
@@ -5,10 +5,9 @@ from typing import TYPE_CHECKING
from django.contrib.auth.models import AbstractUser
from django.contrib.auth.validators import UnicodeUsernameValidator
-from django.core import validators
from django.core.exceptions import ValidationError
from django.db import models
-from django.db.models import F, Q, Value
+from django.db.models import F, Manager, Q, Value
from django.db.models.functions import Concat, Lower
from django.templatetags.static import static
from django.urls import reverse
@@ -19,8 +18,10 @@ from loguru import logger
from management.models import Announcement
from mastodon.api import *
+from takahe.utils import Takahe
if TYPE_CHECKING:
+ from .apidentity import APIdentity
from .preference import Preference
_RESERVED_USERNAMES = [
@@ -48,6 +49,7 @@ class UsernameValidator(UnicodeUsernameValidator):
class User(AbstractUser):
+ identity: "APIdentity"
preference: "Preference"
username_validator = UsernameValidator()
username = models.CharField(
@@ -142,15 +144,6 @@ class User(AbstractUser):
),
]
- @staticmethod
- def register(**param):
- from .preference import Preference
-
- new_user = User(**param)
- new_user.save()
- Preference.objects.create(user=new_user)
- return new_user
-
@cached_property
def mastodon_acct(self):
return (
@@ -185,7 +178,9 @@ class User(AbstractUser):
@property
def handler(self):
- return self.mastodon_acct or self.username or f"~{self.pk}"
+ return (
+ f"{self.username}" if self.username else self.mastodon_acct or f"~{self.pk}"
+ )
@property
def url(self):
@@ -194,105 +189,6 @@ class User(AbstractUser):
def __str__(self):
return f'{self.pk}:{self.username or ""}:{self.mastodon_acct}'
- @property
- def ignoring(self):
- return self.muting + self.rejecting
-
- def follow(self, target: "User"):
- if (
- target is None
- or target.locked
- or self.is_following(target)
- or self.is_blocking(target)
- or self.is_blocked_by(target)
- ):
- return False
- self.local_following.add(target)
- self.following.append(target.pk)
- self.save(update_fields=["following"])
- return True
-
- def unfollow(self, target: "User"):
- if target and target in self.local_following.all():
- self.local_following.remove(target)
- if (
- target.pk in self.following
- and target.mastodon_acct not in self.mastodon_following
- ):
- self.following.remove(target.pk)
- self.save(update_fields=["following"])
- return True
- return False
-
- def remove_follower(self, target: "User"):
- if target is None or self not in target.local_following.all():
- return False
- target.local_following.remove(self)
- if (
- self.pk in target.following
- and self.mastodon_acct not in target.mastodon_following
- ):
- target.following.remove(self.pk)
- target.save(update_fields=["following"])
- return True
-
- def block(self, target: "User"):
- if target is None or target in self.local_blocking.all():
- return False
- self.local_blocking.add(target)
- if target.pk in self.following:
- self.following.remove(target.pk)
- self.save(update_fields=["following"])
- if self.pk in target.following:
- target.following.remove(self.pk)
- target.save(update_fields=["following"])
- if target in self.local_following.all():
- self.local_following.remove(target)
- if self in target.local_following.all():
- target.local_following.remove(self)
- if target.pk not in self.rejecting:
- self.rejecting.append(target.pk)
- self.save(update_fields=["rejecting"])
- if self.pk not in target.rejecting:
- target.rejecting.append(self.pk)
- target.save(update_fields=["rejecting"])
- return True
-
- def unblock(self, target: "User"):
- if target and target in self.local_blocking.all():
- self.local_blocking.remove(target)
- if not self.is_blocked_by(target):
- if target.pk in self.rejecting:
- self.rejecting.remove(target.pk)
- self.save(update_fields=["rejecting"])
- if self.pk in target.rejecting:
- target.rejecting.remove(self.pk)
- target.save(update_fields=["rejecting"])
- return True
- return False
-
- def mute(self, target: "User"):
- if (
- target is None
- or target in self.local_muting.all()
- or target.mastodon_acct in self.mastodon_mutes
- ):
- return False
- self.local_muting.add(target)
- if target.pk not in self.muting:
- self.muting.append(target.pk)
- self.save()
- return True
-
- def unmute(self, target: "User"):
- if target and target in self.local_muting.all():
- self.local_muting.remove(target)
- if target.pk in self.muting:
- self.muting.remove(target.pk)
- self.save()
- return True
- return False
-
def clear(self):
if self.mastodon_site == "removed" and not self.is_active:
return
@@ -313,40 +209,13 @@ class User(AbstractUser):
self.mastodon_blocks = []
self.mastodon_domain_blocks = []
self.mastodon_account = {}
+ self.save()
+ self.identity.deleted = timezone.now()
+ self.identity.save()
- def merge_relationships(self):
- self.muting = self.merged_muting_ids()
- self.rejecting = self.merged_rejecting_ids()
- # caculate following after rejecting is merged
- self.following = self.merged_following_ids()
-
- @classmethod
- def merge_rejected_by(cls):
- """
- Caculate rejecting field to include blocked by for external users
- Should be invoked after invoking merge_relationships() for all users
- """
- # FIXME this is quite inifficient, should only invoked in async task
- external_users = list(
- cls.objects.filter(mastodon_username__isnull=False, is_active=True)
- )
- reject_changed = []
- follow_changed = []
- for u in external_users:
- for v in external_users:
- if v.pk in u.rejecting and u.pk not in v.rejecting:
- v.rejecting.append(u.pk)
- if v not in reject_changed:
- reject_changed.append(v)
- if u.pk in v.following:
- v.following.remove(u.pk)
- if v not in follow_changed:
- follow_changed.append(v)
- for u in reject_changed:
- u.save(update_fields=["rejecting"])
- for u in follow_changed:
- u.save(update_fields=["following"])
- return len(follow_changed) + len(reject_changed)
+ def sync_relationships(self):
+ # FIXME
+ pass
def refresh_mastodon_data(self):
"""Try refresh account data from mastodon server, return true if refreshed successfully, note it will not save to db"""
@@ -390,112 +259,13 @@ class User(AbstractUser):
self.mastodon_domain_blocks = get_related_acct_list(
self.mastodon_site, self.mastodon_token, "/api/v1/domain_blocks"
)
- self.merge_relationships()
+ self.sync_relationships()
updated = True
elif code == 401:
logger.error(f"Refresh mastodon data error 401 for {self}")
self.mastodon_token = ""
return updated
- def merged_following_ids(self):
- fl = []
- for m in self.mastodon_following:
- target = User.get(m)
- if target and (
- (not target.mastodon_locked)
- or self.mastodon_acct in target.mastodon_followers
- ):
- fl.append(target.pk)
- for user in self.local_following.all():
- if user.pk not in fl and not user.locked and not user.is_blocking(self):
- fl.append(user.pk)
- fl = [x for x in fl if x not in self.rejecting]
- return sorted(fl)
-
- def merged_muting_ids(self):
- external_muting_user_ids = list(
- User.objects.all()
- .annotate(acct=Concat("mastodon_username", Value("@"), "mastodon_site"))
- .filter(acct__in=self.mastodon_mutes)
- .values_list("pk", flat=True)
- )
- l = list(
- set(
- external_muting_user_ids
- + list(self.local_muting.all().values_list("pk", flat=True))
- )
- )
- return sorted(l)
-
- def merged_rejecting_ids(self):
- domain_blocked_user_ids = list(
- User.objects.filter(
- mastodon_site__in=self.mastodon_domain_blocks
- ).values_list("pk", flat=True)
- )
- external_blocking_user_ids = list(
- User.objects.all()
- .annotate(acct=Concat("mastodon_username", Value("@"), "mastodon_site"))
- .filter(acct__in=self.mastodon_blocks)
- .values_list("pk", flat=True)
- )
- l = list(
- set(
- domain_blocked_user_ids
- + external_blocking_user_ids
- + list(self.local_blocking.all().values_list("pk", flat=True))
- + list(self.local_blocked_by.all().values_list("pk", flat=True)) # type: ignore
- + list(self.local_muting.all().values_list("pk", flat=True))
- )
- )
- return sorted(l)
-
- def is_blocking(self, target):
- return (
- (
- target in self.local_blocking.all()
- or target.mastodon_acct in self.mastodon_blocks
- or target.mastodon_site in self.mastodon_domain_blocks
- )
- if target.is_authenticated
- else self.preference.no_anonymous_view
- )
-
- def is_blocked_by(self, target):
- return target.is_authenticated and target.is_blocking(self)
-
- def is_muting(self, target):
- return target.pk in self.muting or target.mastodon_acct in self.mastodon_mutes
-
- def is_following(self, target):
- return (
- self.mastodon_acct in target.mastodon_followers
- if target.locked
- else target.pk in self.following
- # or target.mastodon_acct in self.mastodon_following
- # or self.mastodon_acct in target.mastodon_followers
- )
-
- def is_followed_by(self, target):
- return target.is_following(self)
-
- def get_mark_for_item(self, item):
- params = {item.__class__.__name__.lower() + "_id": item.id, "owner": self}
- mark = item.mark_class.objects.filter(**params).first()
- return mark
-
- def get_max_visibility(self, viewer):
- if not viewer.is_authenticated:
- return 0
- elif viewer == self:
- return 2
- elif viewer.is_blocked_by(self):
- return -1
- elif viewer.is_following(self):
- return 1
- else:
- return 0
-
@property
def unread_announcements(self):
unread_announcements = Announcement.objects.filter(
@@ -503,59 +273,71 @@ class User(AbstractUser):
).order_by("-pk")
return unread_announcements
+ @property
+ def activity_manager(self):
+ if not self.identity:
+ raise ValueError("User has no identity")
+ return self.identity.activity_manager
+
+ @property
+ def shelf_manager(self):
+ if not self.identity:
+ raise ValueError("User has no identity")
+ return self.identity.shelf_manager
+
+ @property
+ def tag_manager(self):
+ if not self.identity:
+ raise ValueError("User has no identity")
+ return self.identity.tag_manager
+
@classmethod
def get(cls, name, case_sensitive=False):
if isinstance(name, str):
- sp = name.split("@")
if name.startswith("~"):
try:
query_kwargs = {"pk": int(name[1:])}
except:
return None
- elif len(sp) == 1:
+ elif name.startswith("@"):
query_kwargs = {
- "username__iexact" if case_sensitive else "username": name
- }
- elif len(sp) == 2:
- query_kwargs = {
- "mastodon_username__iexact"
- if case_sensitive
- else "mastodon_username": sp[0],
- "mastodon_site__iexact"
- if case_sensitive
- else "mastodon_site": sp[1],
+ "username__iexact" if case_sensitive else "username": name[1:]
}
else:
- return None
+ sp = name.split("@")
+ if len(sp) == 2:
+ query_kwargs = {
+ "mastodon_username__iexact"
+ if case_sensitive
+ else "mastodon_username": sp[0],
+ "mastodon_site__iexact"
+ if case_sensitive
+ else "mastodon_site": sp[1],
+ }
+ else:
+ return None
elif isinstance(name, int):
query_kwargs = {"pk": name}
else:
return None
return User.objects.filter(**query_kwargs).first()
- @property
- def tags(self):
- from journal.models import TagManager
+ @classmethod
+ def register(cls, **param):
+ from .preference import Preference
- return TagManager.all_tags_for_user(self)
+ new_user = cls(**param)
+ new_user.save()
+ Preference.objects.create(user=new_user)
+ if new_user.username: # TODO make username required in registeration
+ new_user.initialize()
+ return new_user
- @cached_property
- def tag_manager(self):
- from journal.models import TagManager
+ def initialize(self):
+ Takahe.init_identity_for_local_user(self)
- return TagManager.get_manager_for_user(self)
- @cached_property
- def shelf_manager(self):
- from journal.models import ShelfManager
-
- return ShelfManager.get_manager_for_user(self)
-
- @cached_property
- def activity_manager(self):
- from social.models import ActivityManager
-
- return ActivityManager.get_manager_for_user(self)
+# TODO the following models should be deprecated soon
class Follow(models.Model):
diff --git a/users/tasks.py b/users/tasks.py
index 06d684a1..c6cb4c8a 100644
--- a/users/tasks.py
+++ b/users/tasks.py
@@ -42,6 +42,4 @@ def refresh_all_mastodon_data_task(ttl_hours):
else:
logger.warning(f"Missing token for {user}")
logger.info(f"{count} users updated")
- c = User.merge_rejected_by()
- logger.info(f"{c} users's rejecting list updated")
logger.info(f"Mastodon data refresh done")
diff --git a/users/tests.py b/users/tests.py
index 3e801a29..e5513aaf 100644
--- a/users/tests.py
+++ b/users/tests.py
@@ -1,168 +1,70 @@
from django.test import TestCase
+from takahe.utils import Takahe
+
from .models import *
-from .models.user import Block, Follow, Mute
class UserTest(TestCase):
- def setUp(self):
- self.alice = User.register(mastodon_site="MySpace", mastodon_username="Alice")
- self.bob = User.register(mastodon_site="KKCity", mastodon_username="Bob")
+ databases = "__all__"
- def test_local_follow(self):
- self.assertTrue(self.alice.follow(self.bob))
- self.assertTrue(
- Follow.objects.filter(owner=self.alice, target=self.bob).exists()
- )
- self.assertEqual(self.alice.merged_following_ids(), [self.bob.pk])
- self.assertEqual(self.alice.following, [self.bob.pk])
+ def setUp(self):
+ self.alice = User.register(
+ mastodon_site="MySpace", mastodon_username="Alice", username="alice"
+ ).identity
+ self.bob = User.register(
+ mastodon_site="KKCity", mastodon_username="Bob", username="bob"
+ ).identity
+
+ def test_follow(self):
+ self.alice.follow(self.bob)
+ Takahe._force_state_cycle()
self.assertTrue(self.alice.is_following(self.bob))
self.assertTrue(self.bob.is_followed_by(self.alice))
-
- self.assertFalse(self.alice.follow(self.bob))
- self.assertEqual(
- Follow.objects.filter(owner=self.alice, target=self.bob).count(), 1
- )
self.assertEqual(self.alice.following, [self.bob.pk])
- self.assertTrue(self.alice.unfollow(self.bob))
- self.assertFalse(
- Follow.objects.filter(owner=self.alice, target=self.bob).exists()
- )
+ self.alice.unfollow(self.bob)
+ Takahe._force_state_cycle()
self.assertFalse(self.alice.is_following(self.bob))
self.assertFalse(self.bob.is_followed_by(self.alice))
self.assertEqual(self.alice.following, [])
- def test_locked(self):
- self.bob.mastodon_locked = True
- self.bob.save()
- self.assertFalse(self.alice.follow(self.bob))
- self.bob.mastodon_locked = False
- self.bob.save()
- self.assertTrue(self.alice.follow(self.bob))
- self.assertTrue(self.alice.is_following(self.bob))
- self.bob.mastodon_locked = True
- self.bob.save()
- self.assertFalse(self.alice.is_following(self.bob))
-
- def test_external_follow(self):
- self.alice.mastodon_following.append(self.bob.mastodon_acct)
- self.alice.merge_relationships()
- self.alice.save()
- self.assertTrue(self.alice.is_following(self.bob))
- self.assertEqual(self.alice.following, [self.bob.pk])
- self.assertFalse(self.alice.follow(self.bob))
-
- self.alice.mastodon_following.remove(self.bob.mastodon_acct)
- self.alice.merge_relationships()
- self.alice.save()
- self.assertFalse(self.alice.is_following(self.bob))
- self.assertEqual(self.alice.following, [])
- self.assertTrue(self.alice.follow(self.bob))
- self.assertTrue(self.alice.is_following(self.bob))
-
- def test_local_mute(self):
+ def test_mute(self):
self.alice.mute(self.bob)
- self.assertTrue(Mute.objects.filter(owner=self.alice, target=self.bob).exists())
- self.assertEqual(self.alice.merged_muting_ids(), [self.bob.pk])
- self.assertEqual(self.alice.ignoring, [self.bob.pk])
+ Takahe._force_state_cycle()
self.assertTrue(self.alice.is_muting(self.bob))
-
- self.alice.mute(self.bob)
- self.assertEqual(
- Mute.objects.filter(owner=self.alice, target=self.bob).count(), 1
- )
self.assertEqual(self.alice.ignoring, [self.bob.pk])
+ self.assertEqual(self.alice.rejecting, [])
- self.alice.unmute(self.bob)
- self.assertFalse(
- Mute.objects.filter(owner=self.alice, target=self.bob).exists()
- )
- self.assertFalse(self.alice.is_muting(self.bob))
- self.assertEqual(self.alice.ignoring, [])
- self.assertEqual(self.alice.merged_muting_ids(), [])
-
- def test_external_mute(self):
- self.alice.mastodon_mutes.append(self.bob.mastodon_acct)
- self.alice.save()
- self.assertTrue(self.alice.is_muting(self.bob))
- self.assertEqual(self.alice.merged_muting_ids(), [self.bob.pk])
-
- self.alice.mastodon_mutes.remove(self.bob.mastodon_acct)
- self.assertFalse(self.alice.is_muting(self.bob))
- self.assertEqual(self.alice.merged_muting_ids(), [])
-
- def test_local_block_follow(self):
+ def test_block(self):
self.alice.block(self.bob)
- self.assertEqual(self.bob.follow(self.alice), False)
- self.alice.unblock(self.bob)
- self.assertEqual(self.bob.follow(self.alice), True)
- self.assertEqual(self.bob.following, [self.alice.pk])
- self.alice.block(self.bob)
- self.assertEqual(self.bob.following, [])
-
- def test_local_block(self):
- self.alice.block(self.bob)
- self.assertTrue(
- Block.objects.filter(owner=self.alice, target=self.bob).exists()
- )
- self.assertEqual(self.alice.merged_rejecting_ids(), [self.bob.pk])
- self.assertEqual(self.alice.ignoring, [self.bob.pk])
+ Takahe._force_state_cycle()
self.assertTrue(self.alice.is_blocking(self.bob))
self.assertTrue(self.bob.is_blocked_by(self.alice))
-
- self.alice.block(self.bob)
- self.assertEqual(
- Block.objects.filter(owner=self.alice, target=self.bob).count(), 1
- )
+ self.assertEqual(self.alice.rejecting, [self.bob.pk])
self.assertEqual(self.alice.ignoring, [self.bob.pk])
self.alice.unblock(self.bob)
- self.assertFalse(
- Block.objects.filter(owner=self.alice, target=self.bob).exists()
- )
+ Takahe._force_state_cycle()
self.assertFalse(self.alice.is_blocking(self.bob))
self.assertFalse(self.bob.is_blocked_by(self.alice))
+ self.assertEqual(self.alice.rejecting, [])
self.assertEqual(self.alice.ignoring, [])
- self.assertEqual(self.alice.merged_rejecting_ids(), [])
- def test_external_block(self):
- self.bob.follow(self.alice)
- self.assertEqual(self.bob.following, [self.alice.pk])
- self.alice.mastodon_blocks.append(self.bob.mastodon_acct)
- self.alice.save()
- self.assertTrue(self.alice.is_blocking(self.bob))
- self.assertTrue(self.bob.is_blocked_by(self.alice))
- self.assertEqual(self.alice.merged_rejecting_ids(), [self.bob.pk])
- self.alice.merge_relationships()
- self.assertEqual(self.alice.rejecting, [self.bob.pk])
- self.alice.save()
- self.assertEqual(self.bob.following, [self.alice.pk])
- self.assertEqual(self.bob.rejecting, [])
- self.assertEqual(User.merge_rejected_by(), 2)
- self.bob.refresh_from_db()
- self.assertEqual(self.bob.rejecting, [self.alice.pk])
- self.assertEqual(self.bob.following, [])
+ # def test_external_domain_block(self):
+ # self.alice.mastodon_domain_blocks.append(self.bob.mastodon_site)
+ # self.alice.save()
+ # self.assertTrue(self.alice.is_blocking(self.bob))
+ # self.assertTrue(self.bob.is_blocked_by(self.alice))
+ # self.assertEqual(self.alice.merged_rejecting_ids(), [self.bob.pk])
+ # self.alice.merge_relationships()
+ # self.assertEqual(self.alice.rejecting, [self.bob.pk])
+ # self.alice.save()
+ # self.assertEqual(User.merge_rejected_by(), 1)
+ # self.bob.refresh_from_db()
+ # self.assertEqual(self.bob.rejecting, [self.alice.pk])
- self.alice.mastodon_blocks.remove(self.bob.mastodon_acct)
- self.assertFalse(self.alice.is_blocking(self.bob))
- self.assertFalse(self.bob.is_blocked_by(self.alice))
- self.assertEqual(self.alice.merged_rejecting_ids(), [])
-
- def test_external_domain_block(self):
- self.alice.mastodon_domain_blocks.append(self.bob.mastodon_site)
- self.alice.save()
- self.assertTrue(self.alice.is_blocking(self.bob))
- self.assertTrue(self.bob.is_blocked_by(self.alice))
- self.assertEqual(self.alice.merged_rejecting_ids(), [self.bob.pk])
- self.alice.merge_relationships()
- self.assertEqual(self.alice.rejecting, [self.bob.pk])
- self.alice.save()
- self.assertEqual(User.merge_rejected_by(), 1)
- self.bob.refresh_from_db()
- self.assertEqual(self.bob.rejecting, [self.alice.pk])
-
- self.alice.mastodon_domain_blocks.remove(self.bob.mastodon_site)
- self.assertFalse(self.alice.is_blocking(self.bob))
- self.assertFalse(self.bob.is_blocked_by(self.alice))
- self.assertEqual(self.alice.merged_rejecting_ids(), [])
+ # self.alice.mastodon_domain_blocks.remove(self.bob.mastodon_site)
+ # self.assertFalse(self.alice.is_blocking(self.bob))
+ # self.assertFalse(self.bob.is_blocked_by(self.alice))
+ # self.assertEqual(self.alice.merged_rejecting_ids(), [])