2023-08-10 11:27:31 -04:00
|
|
|
import hashlib
|
2023-06-30 23:53:53 -04:00
|
|
|
import re
|
2023-08-10 11:27:31 -04:00
|
|
|
from functools import cached_property
|
|
|
|
from typing import TYPE_CHECKING
|
|
|
|
|
2023-08-14 08:15:55 -04:00
|
|
|
from django.contrib.auth.models import AbstractUser, BaseUserManager
|
2023-08-11 01:43:19 -04:00
|
|
|
from django.contrib.auth.validators import UnicodeUsernameValidator
|
2023-07-04 17:21:17 -04:00
|
|
|
from django.core.exceptions import ValidationError
|
2020-05-01 22:46:15 +08:00
|
|
|
from django.db import models
|
2023-07-20 21:59:49 -04:00
|
|
|
from django.db.models import F, Manager, Q, Value
|
2023-08-10 11:27:31 -04:00
|
|
|
from django.db.models.functions import Concat, Lower
|
|
|
|
from django.templatetags.static import static
|
|
|
|
from django.urls import reverse
|
2020-05-05 23:50:48 +08:00
|
|
|
from django.utils import timezone
|
2023-08-10 11:27:31 -04:00
|
|
|
from django.utils.deconstruct import deconstructible
|
2021-12-24 11:56:04 -08:00
|
|
|
from django.utils.translation import gettext_lazy as _
|
2023-08-10 11:27:31 -04:00
|
|
|
from loguru import logger
|
|
|
|
|
2023-04-20 13:36:12 -04:00
|
|
|
from management.models import Announcement
|
2021-12-14 16:06:27 -05:00
|
|
|
from mastodon.api import *
|
2023-07-20 21:59:49 -04:00
|
|
|
from takahe.utils import Takahe
|
2023-08-10 11:27:31 -04:00
|
|
|
|
|
|
|
if TYPE_CHECKING:
|
2023-07-20 21:59:49 -04:00
|
|
|
from .apidentity import APIdentity
|
2023-08-10 11:27:31 -04:00
|
|
|
from .preference import Preference
|
2023-07-04 17:21:17 -04:00
|
|
|
|
2023-07-12 01:11:15 -04:00
|
|
|
_RESERVED_USERNAMES = [
|
2023-07-04 17:21:17 -04:00
|
|
|
"connect",
|
|
|
|
"oauth2_login",
|
|
|
|
"__",
|
|
|
|
"admin",
|
|
|
|
"api",
|
|
|
|
"me",
|
|
|
|
]
|
2020-05-01 22:46:15 +08:00
|
|
|
|
|
|
|
|
2023-06-30 23:53:53 -04:00
|
|
|
@deconstructible
|
2023-08-11 01:43:19 -04:00
|
|
|
class UsernameValidator(UnicodeUsernameValidator):
|
2023-07-04 17:21:17 -04:00
|
|
|
regex = r"^[a-zA-Z0-9_]{2,30}$"
|
2023-06-30 23:53:53 -04:00
|
|
|
message = _(
|
2023-08-10 11:27:31 -04:00
|
|
|
"Enter a valid username. This value may contain only unaccented lowercase a-z and uppercase A-Z letters, numbers, and _ characters."
|
2023-06-30 23:53:53 -04:00
|
|
|
)
|
|
|
|
flags = re.ASCII
|
|
|
|
|
2023-07-04 17:21:17 -04:00
|
|
|
def __call__(self, value):
|
2023-07-12 01:11:15 -04:00
|
|
|
if value and value.lower() in _RESERVED_USERNAMES:
|
2023-07-04 17:21:17 -04:00
|
|
|
raise ValidationError(self.message, code=self.code)
|
|
|
|
return super().__call__(value)
|
|
|
|
|
2023-06-30 23:53:53 -04:00
|
|
|
|
2023-08-14 08:15:55 -04:00
|
|
|
class UserManager(BaseUserManager):
|
|
|
|
def create_user(self, username, email, password=None):
|
|
|
|
Takahe.get_domain() # ensure configuration is complete
|
|
|
|
user = User.register(username=username, email=email)
|
|
|
|
return user
|
|
|
|
|
|
|
|
def create_superuser(self, username, email, password=None):
|
|
|
|
from takahe.models import User as TakaheUser
|
|
|
|
|
|
|
|
Takahe.get_domain() # ensure configuration is complete
|
|
|
|
user = User.register(username=username, email=email, is_superuser=True)
|
|
|
|
tu = TakaheUser.objects.get(pk=user.pk, email="@" + username)
|
|
|
|
tu.admin = True
|
|
|
|
tu.set_password(password)
|
|
|
|
tu.save()
|
|
|
|
return user
|
|
|
|
|
|
|
|
|
2020-05-01 22:46:15 +08:00
|
|
|
class User(AbstractUser):
|
2023-07-20 21:59:49 -04:00
|
|
|
identity: "APIdentity"
|
2023-07-12 01:11:15 -04:00
|
|
|
preference: "Preference"
|
2023-06-30 23:53:53 -04:00
|
|
|
username_validator = UsernameValidator()
|
|
|
|
username = models.CharField(
|
|
|
|
_("username"),
|
2023-07-02 16:56:09 -04:00
|
|
|
max_length=100,
|
2023-06-30 23:53:53 -04:00
|
|
|
unique=True,
|
|
|
|
null=True, # allow null for newly registered users who has not set a user name
|
|
|
|
help_text=_("Required. 50 characters or fewer. Letters, digits and _ only."),
|
|
|
|
validators=[username_validator],
|
|
|
|
error_messages={
|
|
|
|
"unique": _("A user with that username already exists."),
|
|
|
|
},
|
|
|
|
)
|
2023-07-07 02:02:48 -04:00
|
|
|
email = models.EmailField(
|
|
|
|
_("email address"),
|
|
|
|
unique=True,
|
|
|
|
default=None,
|
|
|
|
null=True,
|
|
|
|
)
|
2023-07-04 17:21:17 -04:00
|
|
|
pending_email = models.EmailField(
|
|
|
|
_("email address pending verification"), default=None, null=True
|
|
|
|
)
|
2023-07-07 02:02:48 -04:00
|
|
|
local_following = models.ManyToManyField(
|
|
|
|
through="Follow",
|
|
|
|
to="self",
|
|
|
|
through_fields=("owner", "target"),
|
|
|
|
symmetrical=False,
|
|
|
|
related_name="local_followers",
|
|
|
|
)
|
2023-07-07 16:54:15 -04:00
|
|
|
local_blocking = models.ManyToManyField(
|
|
|
|
through="Block",
|
|
|
|
to="self",
|
|
|
|
through_fields=("owner", "target"),
|
|
|
|
symmetrical=False,
|
|
|
|
related_name="local_blocked_by",
|
|
|
|
)
|
|
|
|
local_muting = models.ManyToManyField(
|
|
|
|
through="Mute",
|
|
|
|
to="self",
|
|
|
|
through_fields=("owner", "target"),
|
|
|
|
symmetrical=False,
|
|
|
|
related_name="+",
|
|
|
|
)
|
2022-05-30 17:54:35 -04:00
|
|
|
following = models.JSONField(default=list)
|
2023-07-07 16:54:15 -04:00
|
|
|
muting = models.JSONField(default=list)
|
|
|
|
# rejecting = local/external blocking + local/external blocked_by + domain_blocking + domain_blocked_by
|
|
|
|
rejecting = models.JSONField(default=list)
|
2023-06-30 23:53:53 -04:00
|
|
|
mastodon_id = models.CharField(max_length=100, default=None, null=True)
|
|
|
|
mastodon_username = models.CharField(max_length=100, default=None, null=True)
|
|
|
|
mastodon_site = models.CharField(max_length=100, default=None, null=True)
|
2023-01-01 23:50:57 -05:00
|
|
|
mastodon_token = models.CharField(max_length=2048, default="")
|
|
|
|
mastodon_refresh_token = models.CharField(max_length=2048, default="")
|
2021-12-14 16:06:27 -05:00
|
|
|
mastodon_locked = models.BooleanField(default=False)
|
|
|
|
mastodon_followers = models.JSONField(default=list)
|
|
|
|
mastodon_following = models.JSONField(default=list)
|
|
|
|
mastodon_mutes = models.JSONField(default=list)
|
|
|
|
mastodon_blocks = models.JSONField(default=list)
|
2021-12-15 00:16:48 -05:00
|
|
|
mastodon_domain_blocks = models.JSONField(default=list)
|
2021-12-14 16:06:27 -05:00
|
|
|
mastodon_account = models.JSONField(default=dict)
|
|
|
|
mastodon_last_refresh = models.DateTimeField(default=timezone.now)
|
2022-05-13 00:11:59 -04:00
|
|
|
# store the latest read announcement id,
|
2020-12-09 13:47:00 +01:00
|
|
|
# every time user read the announcement update this field
|
|
|
|
read_announcement_index = models.PositiveIntegerField(default=0)
|
2023-08-14 08:15:55 -04:00
|
|
|
objects = UserManager()
|
2020-10-22 21:45:05 +02:00
|
|
|
|
|
|
|
class Meta:
|
|
|
|
constraints = [
|
|
|
|
models.UniqueConstraint(
|
2023-07-06 20:50:06 -04:00
|
|
|
Lower("username"),
|
|
|
|
name="unique_username",
|
|
|
|
),
|
|
|
|
models.UniqueConstraint(
|
|
|
|
Lower("email"),
|
|
|
|
name="unique_email",
|
|
|
|
),
|
|
|
|
models.UniqueConstraint(
|
|
|
|
Lower("mastodon_username"),
|
|
|
|
Lower("mastodon_site"),
|
2023-06-30 23:53:53 -04:00
|
|
|
name="unique_mastodon_username",
|
|
|
|
),
|
|
|
|
models.UniqueConstraint(
|
2023-07-06 20:50:06 -04:00
|
|
|
Lower("mastodon_id"),
|
|
|
|
Lower("mastodon_site"),
|
2023-06-30 23:53:53 -04:00
|
|
|
name="unique_mastodon_id",
|
|
|
|
),
|
2023-07-04 17:21:17 -04:00
|
|
|
models.CheckConstraint(
|
|
|
|
check=(
|
|
|
|
Q(is_active=False)
|
|
|
|
| Q(mastodon_username__isnull=False)
|
|
|
|
| Q(email__isnull=False)
|
|
|
|
),
|
|
|
|
name="at_least_one_login_method",
|
|
|
|
),
|
2020-10-22 21:45:05 +02:00
|
|
|
]
|
2020-05-01 22:46:15 +08:00
|
|
|
|
2023-07-07 16:54:15 -04:00
|
|
|
@cached_property
|
2023-06-30 23:53:53 -04:00
|
|
|
def mastodon_acct(self):
|
|
|
|
return (
|
|
|
|
f"{self.mastodon_username}@{self.mastodon_site}"
|
|
|
|
if self.mastodon_username
|
|
|
|
else ""
|
|
|
|
)
|
2020-10-30 13:18:31 +01:00
|
|
|
|
2023-07-07 02:02:48 -04:00
|
|
|
@property
|
|
|
|
def locked(self):
|
|
|
|
return self.mastodon_locked
|
|
|
|
|
2022-05-30 19:43:29 -04:00
|
|
|
@property
|
|
|
|
def display_name(self):
|
2023-01-01 23:50:57 -05:00
|
|
|
return (
|
2023-07-12 17:55:48 -04:00
|
|
|
(self.mastodon_account.get("display_name") if self.mastodon_account else "")
|
|
|
|
or self.username
|
|
|
|
or self.mastodon_acct
|
|
|
|
or ""
|
2023-01-01 23:50:57 -05:00
|
|
|
)
|
2022-05-30 19:43:29 -04:00
|
|
|
|
2023-07-05 00:47:54 -04:00
|
|
|
@property
|
|
|
|
def avatar(self):
|
2023-08-22 17:13:52 +00:00
|
|
|
return self.identity.avatar if self.identity else static("img/avatar.svg")
|
2023-07-05 00:47:54 -04:00
|
|
|
|
2023-06-30 23:53:53 -04:00
|
|
|
@property
|
|
|
|
def handler(self):
|
2023-07-20 21:59:49 -04:00
|
|
|
return (
|
|
|
|
f"{self.username}" if self.username else self.mastodon_acct or f"~{self.pk}"
|
|
|
|
)
|
2023-06-30 23:53:53 -04:00
|
|
|
|
2022-11-08 02:32:35 +00:00
|
|
|
@property
|
|
|
|
def url(self):
|
2023-06-30 23:53:53 -04:00
|
|
|
return reverse("journal:user_profile", args=[self.handler])
|
2022-11-08 02:32:35 +00:00
|
|
|
|
2021-12-15 00:16:48 -05:00
|
|
|
def __str__(self):
|
2023-06-30 23:53:53 -04:00
|
|
|
return f'{self.pk}:{self.username or ""}:{self.mastodon_acct}'
|
2021-12-15 00:16:48 -05:00
|
|
|
|
2023-06-30 23:53:53 -04:00
|
|
|
def clear(self):
|
|
|
|
if self.mastodon_site == "removed" and not self.is_active:
|
|
|
|
return
|
2023-07-05 00:47:54 -04:00
|
|
|
self.first_name = self.mastodon_acct or ""
|
|
|
|
self.last_name = self.email or ""
|
2023-06-30 23:53:53 -04:00
|
|
|
self.is_active = False
|
|
|
|
self.email = None
|
|
|
|
# self.username = "~removed~" + str(self.pk)
|
|
|
|
# to get ready for federation, username has to be reserved
|
2023-07-05 00:47:54 -04:00
|
|
|
self.mastodon_username = None
|
2023-06-30 23:53:53 -04:00
|
|
|
self.mastodon_id = None
|
|
|
|
self.mastodon_site = "removed"
|
|
|
|
self.mastodon_token = ""
|
|
|
|
self.mastodon_locked = False
|
|
|
|
self.mastodon_followers = []
|
|
|
|
self.mastodon_following = []
|
|
|
|
self.mastodon_mutes = []
|
|
|
|
self.mastodon_blocks = []
|
|
|
|
self.mastodon_domain_blocks = []
|
|
|
|
self.mastodon_account = {}
|
2023-07-20 21:59:49 -04:00
|
|
|
self.save()
|
|
|
|
self.identity.deleted = timezone.now()
|
|
|
|
self.identity.save()
|
2023-06-30 23:53:53 -04:00
|
|
|
|
2023-07-20 21:59:49 -04:00
|
|
|
def sync_relationships(self):
|
|
|
|
# FIXME
|
|
|
|
pass
|
2023-07-07 16:54:15 -04:00
|
|
|
|
2021-12-14 16:06:27 -05:00
|
|
|
def refresh_mastodon_data(self):
|
2023-01-01 23:50:57 -05:00
|
|
|
"""Try refresh account data from mastodon server, return true if refreshed successfully, note it will not save to db"""
|
2021-12-14 16:06:27 -05:00
|
|
|
self.mastodon_last_refresh = timezone.now()
|
|
|
|
code, mastodon_account = verify_account(self.mastodon_site, self.mastodon_token)
|
2022-04-01 20:03:37 -04:00
|
|
|
if code == 401 and self.mastodon_refresh_token:
|
2023-01-01 23:50:57 -05:00
|
|
|
self.mastodon_token = refresh_access_token(
|
|
|
|
self.mastodon_site, self.mastodon_refresh_token
|
|
|
|
)
|
2022-04-01 20:03:37 -04:00
|
|
|
if self.mastodon_token:
|
2023-01-01 23:50:57 -05:00
|
|
|
code, mastodon_account = verify_account(
|
|
|
|
self.mastodon_site, self.mastodon_token
|
|
|
|
)
|
2021-12-14 16:06:27 -05:00
|
|
|
updated = False
|
|
|
|
if mastodon_account:
|
|
|
|
self.mastodon_account = mastodon_account
|
2023-01-01 23:50:57 -05:00
|
|
|
self.mastodon_locked = mastodon_account["locked"]
|
2023-06-30 23:53:53 -04:00
|
|
|
if self.mastodon_username != mastodon_account["username"]:
|
2023-07-09 02:12:28 -04:00
|
|
|
logger.warning(
|
2023-06-30 23:53:53 -04:00
|
|
|
f"username changed from {self} to {mastodon_account['username']}"
|
|
|
|
)
|
|
|
|
self.mastodon_username = mastodon_account["username"]
|
2021-12-14 16:06:27 -05:00
|
|
|
# self.mastodon_token = token
|
|
|
|
# user.mastodon_id = mastodon_account['id']
|
2023-01-01 23:50:57 -05:00
|
|
|
self.mastodon_followers = get_related_acct_list(
|
|
|
|
self.mastodon_site,
|
|
|
|
self.mastodon_token,
|
|
|
|
f"/api/v1/accounts/{self.mastodon_id}/followers",
|
|
|
|
)
|
|
|
|
self.mastodon_following = get_related_acct_list(
|
|
|
|
self.mastodon_site,
|
|
|
|
self.mastodon_token,
|
|
|
|
f"/api/v1/accounts/{self.mastodon_id}/following",
|
|
|
|
)
|
|
|
|
self.mastodon_mutes = get_related_acct_list(
|
|
|
|
self.mastodon_site, self.mastodon_token, "/api/v1/mutes"
|
|
|
|
)
|
|
|
|
self.mastodon_blocks = get_related_acct_list(
|
|
|
|
self.mastodon_site, self.mastodon_token, "/api/v1/blocks"
|
|
|
|
)
|
|
|
|
self.mastodon_domain_blocks = get_related_acct_list(
|
|
|
|
self.mastodon_site, self.mastodon_token, "/api/v1/domain_blocks"
|
|
|
|
)
|
2023-07-20 21:59:49 -04:00
|
|
|
self.sync_relationships()
|
2021-12-14 16:06:27 -05:00
|
|
|
updated = True
|
|
|
|
elif code == 401:
|
2023-07-12 23:05:19 -04:00
|
|
|
logger.error(f"Refresh mastodon data error 401 for {self}")
|
2023-01-01 23:50:57 -05:00
|
|
|
self.mastodon_token = ""
|
2021-12-14 16:06:27 -05:00
|
|
|
return updated
|
|
|
|
|
2023-04-20 13:36:12 -04:00
|
|
|
@property
|
|
|
|
def unread_announcements(self):
|
|
|
|
unread_announcements = Announcement.objects.filter(
|
|
|
|
pk__gt=self.read_announcement_index
|
|
|
|
).order_by("-pk")
|
|
|
|
return unread_announcements
|
|
|
|
|
2023-07-20 21:59:49 -04:00
|
|
|
@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
|
|
|
|
|
2022-05-13 00:11:59 -04:00
|
|
|
@classmethod
|
2023-07-08 00:44:22 -04:00
|
|
|
def get(cls, name, case_sensitive=False):
|
2023-06-30 23:53:53 -04:00
|
|
|
if isinstance(name, str):
|
2023-07-05 00:47:54 -04:00
|
|
|
if name.startswith("~"):
|
|
|
|
try:
|
|
|
|
query_kwargs = {"pk": int(name[1:])}
|
|
|
|
except:
|
|
|
|
return None
|
2023-07-20 21:59:49 -04:00
|
|
|
elif name.startswith("@"):
|
2023-07-08 00:44:22 -04:00
|
|
|
query_kwargs = {
|
2023-07-20 21:59:49 -04:00
|
|
|
"username__iexact" if case_sensitive else "username": name[1:]
|
2023-07-08 00:44:22 -04:00
|
|
|
}
|
2023-06-30 23:53:53 -04:00
|
|
|
else:
|
2023-07-20 21:59:49 -04:00
|
|
|
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
|
2023-07-05 00:47:54 -04:00
|
|
|
elif isinstance(name, int):
|
|
|
|
query_kwargs = {"pk": name}
|
2022-05-13 00:11:59 -04:00
|
|
|
else:
|
|
|
|
return None
|
|
|
|
return User.objects.filter(**query_kwargs).first()
|
|
|
|
|
2023-07-20 21:59:49 -04:00
|
|
|
@classmethod
|
|
|
|
def register(cls, **param):
|
|
|
|
from .preference import Preference
|
2023-08-10 11:27:31 -04:00
|
|
|
|
2023-07-20 21:59:49 -04:00
|
|
|
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
|
2023-08-10 11:27:31 -04:00
|
|
|
|
2023-08-13 23:11:12 -04:00
|
|
|
def identity_linked(self):
|
|
|
|
from .apidentity import APIdentity
|
|
|
|
|
|
|
|
return APIdentity.objects.filter(user=self).exists()
|
|
|
|
|
2023-07-20 21:59:49 -04:00
|
|
|
def initialize(self):
|
|
|
|
Takahe.init_identity_for_local_user(self)
|
2023-08-13 23:11:12 -04:00
|
|
|
self.identity.shelf_manager
|
2021-02-17 17:36:22 +01:00
|
|
|
|
2023-08-11 01:43:19 -04:00
|
|
|
|
2023-07-20 21:59:49 -04:00
|
|
|
# TODO the following models should be deprecated soon
|
2023-08-11 01:43:19 -04:00
|
|
|
|
2021-02-17 15:08:16 +01:00
|
|
|
|
2023-07-07 02:02:48 -04:00
|
|
|
class Follow(models.Model):
|
|
|
|
owner = models.ForeignKey(User, on_delete=models.CASCADE, related_name="+")
|
|
|
|
target = models.ForeignKey(User, on_delete=models.CASCADE, related_name="+")
|
|
|
|
created_time = models.DateTimeField(auto_now_add=True)
|
|
|
|
edited_time = models.DateTimeField(auto_now=True)
|
|
|
|
|
|
|
|
|
2023-07-07 16:54:15 -04:00
|
|
|
class Block(models.Model):
|
|
|
|
owner = models.ForeignKey(User, on_delete=models.CASCADE, related_name="+")
|
|
|
|
target = models.ForeignKey(User, on_delete=models.CASCADE, related_name="+")
|
|
|
|
created_time = models.DateTimeField(auto_now_add=True)
|
|
|
|
edited_time = models.DateTimeField(auto_now=True)
|
|
|
|
|
|
|
|
|
|
|
|
class Mute(models.Model):
|
|
|
|
owner = models.ForeignKey(User, on_delete=models.CASCADE, related_name="+")
|
|
|
|
target = models.ForeignKey(User, on_delete=models.CASCADE, related_name="+")
|
|
|
|
created_time = models.DateTimeField(auto_now_add=True)
|
|
|
|
edited_time = models.DateTimeField(auto_now=True)
|