2022-11-05 19:10:39 -07:00
|
|
|
import string
|
|
|
|
|
2022-11-05 13:17:27 -07:00
|
|
|
from django import forms
|
|
|
|
from django.contrib.auth.decorators import login_required
|
2022-11-18 07:28:15 -08:00
|
|
|
from django.http import Http404, JsonResponse
|
2022-11-05 13:17:27 -07:00
|
|
|
from django.shortcuts import redirect
|
|
|
|
from django.utils.decorators import method_decorator
|
|
|
|
from django.views.generic import FormView, TemplateView, View
|
|
|
|
|
2022-11-18 07:28:15 -08:00
|
|
|
from core.ld import canonicalise
|
2022-11-16 16:23:46 -08:00
|
|
|
from core.models import Config
|
2022-11-06 20:30:07 -08:00
|
|
|
from users.decorators import identity_required
|
2022-11-16 21:23:32 -08:00
|
|
|
from users.models import Domain, Follow, FollowStates, Identity, IdentityStates
|
2022-11-05 13:17:27 -07:00
|
|
|
from users.shortcuts import by_handle_or_404
|
|
|
|
|
|
|
|
|
|
|
|
class ViewIdentity(TemplateView):
|
2022-11-18 07:28:15 -08:00
|
|
|
"""
|
|
|
|
Shows identity profile pages, and also acts as the Actor endpoint when
|
|
|
|
approached with the right Accept header.
|
|
|
|
"""
|
2022-11-05 13:17:27 -07:00
|
|
|
|
|
|
|
template_name = "identity/view.html"
|
|
|
|
|
2022-11-18 07:28:15 -08:00
|
|
|
def get(self, request, handle):
|
|
|
|
# Make sure we understand this handle
|
2022-11-06 20:30:07 -08:00
|
|
|
identity = by_handle_or_404(
|
|
|
|
self.request,
|
|
|
|
handle,
|
|
|
|
local=False,
|
|
|
|
fetch=True,
|
|
|
|
)
|
2022-11-18 07:28:15 -08:00
|
|
|
# If they're coming in looking for JSON, they want the actor
|
|
|
|
accept = request.META.get("HTTP_ACCEPT", "text/html").lower()
|
|
|
|
if (
|
|
|
|
"application/json" in accept
|
|
|
|
or "application/ld" in accept
|
|
|
|
or "application/activity" in accept
|
|
|
|
):
|
|
|
|
# Return actor info
|
|
|
|
return self.serve_actor(identity)
|
|
|
|
else:
|
|
|
|
# Show normal page
|
|
|
|
return super().get(request, identity=identity)
|
|
|
|
|
|
|
|
def serve_actor(self, identity):
|
|
|
|
# If this not a local actor, redirect to their canonical URI
|
|
|
|
if not identity.local:
|
|
|
|
return redirect(identity.actor_uri)
|
|
|
|
return JsonResponse(canonicalise(identity.to_ap(), include_security=True))
|
|
|
|
|
|
|
|
def get_context_data(self, identity):
|
2022-11-11 22:04:43 -08:00
|
|
|
posts = identity.posts.all()[:100]
|
2022-11-16 16:23:46 -08:00
|
|
|
if identity.data_age > Config.system.identity_max_age:
|
2022-11-09 21:29:33 -08:00
|
|
|
identity.transition_perform(IdentityStates.outdated)
|
2022-11-16 21:23:32 -08:00
|
|
|
follow = None
|
2022-11-17 19:04:01 -08:00
|
|
|
reverse_follow = None
|
2022-11-16 21:23:32 -08:00
|
|
|
if self.request.identity:
|
|
|
|
follow = Follow.maybe_get(self.request.identity, identity)
|
2022-11-17 19:04:01 -08:00
|
|
|
if follow and follow.state not in FollowStates.group_active():
|
2022-11-16 21:23:32 -08:00
|
|
|
follow = None
|
2022-11-17 19:04:01 -08:00
|
|
|
reverse_follow = Follow.maybe_get(identity, self.request.identity)
|
|
|
|
if (
|
|
|
|
reverse_follow
|
|
|
|
and reverse_follow.state not in FollowStates.group_active()
|
|
|
|
):
|
|
|
|
reverse_follow = None
|
2022-11-05 13:17:27 -07:00
|
|
|
return {
|
|
|
|
"identity": identity,
|
2022-11-11 22:04:43 -08:00
|
|
|
"posts": posts,
|
2022-11-16 21:23:32 -08:00
|
|
|
"follow": follow,
|
2022-11-17 19:04:01 -08:00
|
|
|
"reverse_follow": reverse_follow,
|
2022-11-05 13:17:27 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2022-11-06 20:30:07 -08:00
|
|
|
@method_decorator(identity_required, name="dispatch")
|
|
|
|
class ActionIdentity(View):
|
|
|
|
def post(self, request, handle):
|
|
|
|
identity = by_handle_or_404(self.request, handle, local=False)
|
|
|
|
# See what action we should perform
|
|
|
|
action = self.request.POST["action"]
|
|
|
|
if action == "follow":
|
|
|
|
existing_follow = Follow.maybe_get(self.request.identity, identity)
|
|
|
|
if not existing_follow:
|
|
|
|
Follow.create_local(self.request.identity, identity)
|
2022-11-16 21:23:32 -08:00
|
|
|
elif existing_follow.state in [
|
|
|
|
FollowStates.undone,
|
|
|
|
FollowStates.undone_remotely,
|
|
|
|
]:
|
|
|
|
existing_follow.transition_perform(FollowStates.unrequested)
|
|
|
|
elif action == "unfollow":
|
|
|
|
existing_follow = Follow.maybe_get(self.request.identity, identity)
|
|
|
|
if existing_follow:
|
|
|
|
existing_follow.transition_perform(FollowStates.undone)
|
2022-11-06 20:30:07 -08:00
|
|
|
else:
|
|
|
|
raise ValueError(f"Cannot handle identity action {action}")
|
|
|
|
return redirect(identity.urls.view)
|
|
|
|
|
|
|
|
|
2022-11-05 13:17:27 -07:00
|
|
|
@method_decorator(login_required, name="dispatch")
|
|
|
|
class SelectIdentity(TemplateView):
|
|
|
|
|
|
|
|
template_name = "identity/select.html"
|
|
|
|
|
|
|
|
def get_context_data(self):
|
|
|
|
return {
|
|
|
|
"identities": Identity.objects.filter(users__pk=self.request.user.pk),
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2022-11-05 19:10:39 -07:00
|
|
|
@method_decorator(login_required, name="dispatch")
|
|
|
|
class ActivateIdentity(View):
|
|
|
|
def get(self, request, handle):
|
|
|
|
identity = by_handle_or_404(request, handle)
|
|
|
|
if not identity.users.filter(pk=request.user.pk).exists():
|
|
|
|
raise Http404()
|
|
|
|
request.session["identity_id"] = identity.id
|
|
|
|
# Get next URL, not allowing offsite links
|
|
|
|
next = request.GET.get("next") or "/"
|
|
|
|
if ":" in next:
|
|
|
|
next = "/"
|
|
|
|
return redirect("/")
|
|
|
|
|
|
|
|
|
2022-11-05 13:17:27 -07:00
|
|
|
@method_decorator(login_required, name="dispatch")
|
|
|
|
class CreateIdentity(FormView):
|
|
|
|
|
|
|
|
template_name = "identity/create.html"
|
|
|
|
|
|
|
|
class form_class(forms.Form):
|
2022-11-13 15:14:38 -08:00
|
|
|
username = forms.CharField(
|
|
|
|
help_text="Must be unique on your domain. Cannot be changed easily. Use only: a-z 0-9 _ -"
|
|
|
|
)
|
|
|
|
domain = forms.ChoiceField(
|
|
|
|
help_text="Pick the domain to make this identity on. Cannot be changed later."
|
|
|
|
)
|
|
|
|
name = forms.CharField(
|
|
|
|
help_text="The display name other users see. You can change this easily."
|
|
|
|
)
|
2022-11-05 13:17:27 -07:00
|
|
|
|
2022-11-06 12:48:04 -08:00
|
|
|
def __init__(self, user, *args, **kwargs):
|
|
|
|
super().__init__(*args, **kwargs)
|
2022-11-13 15:14:38 -08:00
|
|
|
self.fields["domain"].choices = [
|
|
|
|
(domain.domain, domain.domain)
|
|
|
|
for domain in Domain.available_for_user(user)
|
|
|
|
]
|
2022-11-06 12:48:04 -08:00
|
|
|
|
|
|
|
def clean_username(self):
|
2022-11-13 15:14:38 -08:00
|
|
|
# Remove any leading @ and force it lowercase
|
|
|
|
value = self.cleaned_data["username"].lstrip("@").lower()
|
2022-11-05 19:10:39 -07:00
|
|
|
# Validate it's all ascii characters
|
|
|
|
for character in value:
|
|
|
|
if character not in string.ascii_letters + string.digits + "_-":
|
|
|
|
raise forms.ValidationError(
|
2022-11-13 15:14:38 -08:00
|
|
|
"Only the letters a-z, numbers 0-9, dashes, and underscores are allowed."
|
2022-11-05 19:10:39 -07:00
|
|
|
)
|
2022-11-05 13:17:27 -07:00
|
|
|
return value
|
|
|
|
|
2022-11-06 12:48:04 -08:00
|
|
|
def clean(self):
|
|
|
|
# Check for existing users
|
2022-11-09 22:48:31 -08:00
|
|
|
username = self.cleaned_data.get("username")
|
|
|
|
domain = self.cleaned_data.get("domain")
|
|
|
|
if (
|
|
|
|
username
|
|
|
|
and domain
|
|
|
|
and Identity.objects.filter(username=username, domain=domain).exists()
|
|
|
|
):
|
2022-11-06 12:48:04 -08:00
|
|
|
raise forms.ValidationError(f"{username}@{domain} is already taken")
|
|
|
|
|
|
|
|
def get_form(self):
|
|
|
|
form_class = self.get_form_class()
|
|
|
|
return form_class(user=self.request.user, **self.get_form_kwargs())
|
|
|
|
|
2022-11-05 13:17:27 -07:00
|
|
|
def form_valid(self, form):
|
2022-11-06 12:48:04 -08:00
|
|
|
username = form.cleaned_data["username"]
|
|
|
|
domain = form.cleaned_data["domain"]
|
2022-11-09 21:29:33 -08:00
|
|
|
domain_instance = Domain.get_domain(domain)
|
2022-11-05 13:17:27 -07:00
|
|
|
new_identity = Identity.objects.create(
|
2022-11-18 07:28:15 -08:00
|
|
|
actor_uri=f"https://{domain_instance.uri_domain}/@{username}@{domain}/",
|
2022-11-16 22:10:55 -08:00
|
|
|
username=username.lower(),
|
2022-11-06 12:48:04 -08:00
|
|
|
domain_id=domain,
|
2022-11-05 13:17:27 -07:00
|
|
|
name=form.cleaned_data["name"],
|
|
|
|
local=True,
|
|
|
|
)
|
|
|
|
new_identity.users.add(self.request.user)
|
|
|
|
new_identity.generate_keypair()
|
|
|
|
return redirect(new_identity.urls.view)
|