lib.itmens/users/views.py

279 lines
8.1 KiB
Python
Raw Normal View History

import json
from discord import SyncWebhook
2020-05-05 23:50:48 +08:00
from django.contrib.auth.decorators import login_required
from django.core.exceptions import BadRequest, PermissionDenied
from django.http import HttpResponseRedirect
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse
2020-05-05 23:50:48 +08:00
from django.utils.translation import gettext_lazy as _
from common.config import *
2023-08-13 23:11:12 -04:00
from common.utils import (
AuthedHttpRequest,
HTTPResponseHXRedirect,
target_identity_required,
)
from management.models import Announcement
2020-10-22 21:45:05 +02:00
from mastodon.api import *
2023-08-13 18:00:10 -04:00
from takahe.utils import Takahe
from .account import *
from .data import *
from .forms import ReportForm
2023-08-13 18:00:10 -04:00
from .models import APIdentity, Preference, Report, User
2023-08-22 17:13:52 +00:00
from .profile import account_info, account_profile
2020-05-01 22:46:15 +08:00
2023-08-13 18:00:10 -04:00
def render_user_not_found(request, user_name=""):
2023-07-07 16:54:15 -04:00
sec_msg = _("😖哎呀这位用户好像还没有加入本站快去联邦宇宙呼唤TA来注册吧")
2023-08-13 18:00:10 -04:00
msg = _("未找到用户") + user_name
2022-05-12 08:14:05 -04:00
return render(
request,
"common/error.html",
2022-05-12 08:14:05 -04:00
{
"msg": msg,
"secondary_msg": sec_msg,
},
2022-05-12 08:14:05 -04:00
)
2022-12-27 14:52:03 -05:00
def render_user_blocked(request):
2023-07-07 16:54:15 -04:00
msg = _("没有访问该用户主页的权限")
2022-12-27 14:52:03 -05:00
return render(
request,
"common/error.html",
2022-12-27 14:52:03 -05:00
{
"msg": msg,
},
2022-12-27 14:52:03 -05:00
)
2023-08-13 18:00:10 -04:00
def query_identity(request, handle):
try:
i = APIdentity.get_by_handler(handle)
return redirect(i.url)
except APIdentity.DoesNotExist:
if len(handle.split("@")) == 3:
Takahe.fetch_remote_identity(handle)
return render(
request, "users/fetch_identity_pending.html", {"handle": handle}
)
else:
return render_user_not_found(request, handle)
def fetch_refresh(request):
handle = request.GET.get("handle", "")
try:
i = APIdentity.get_by_handler(handle)
return HTTPResponseHXRedirect(i.url)
except:
retry = int(request.GET.get("retry", 0)) + 1
if retry > 10:
return render(request, "users/fetch_identity_failed.html")
else:
return render(
request,
"users/fetch_identity_refresh.html",
{"handle": handle, "retry": retry, "delay": retry * 2},
)
2023-07-07 02:02:48 -04:00
@login_required
2023-08-13 23:11:12 -04:00
@target_identity_required
def follow(request: AuthedHttpRequest, user_name):
2023-07-07 02:02:48 -04:00
if request.method != "POST":
raise BadRequest()
2023-08-13 23:11:12 -04:00
request.user.identity.follow(request.target_identity)
return render(
request,
"users/profile_actions.html",
context={"identity": request.target_identity},
)
2023-07-07 02:02:48 -04:00
@login_required
2023-08-13 23:11:12 -04:00
@target_identity_required
def unfollow(request: AuthedHttpRequest, user_name):
2023-07-07 02:02:48 -04:00
if request.method != "POST":
raise BadRequest()
2023-08-13 23:11:12 -04:00
request.user.identity.unfollow(request.target_identity)
return render(
request,
"users/profile_actions.html",
context={"identity": request.target_identity},
)
2023-07-07 16:54:15 -04:00
@login_required
2023-08-13 23:11:12 -04:00
@target_identity_required
def mute(request: AuthedHttpRequest, user_name):
2023-07-07 16:54:15 -04:00
if request.method != "POST":
raise BadRequest()
2023-08-13 23:11:12 -04:00
request.user.identity.mute(request.target_identity)
return render(
request,
"users/profile_actions.html",
context={"identity": request.target_identity},
)
2023-07-07 16:54:15 -04:00
@login_required
2023-08-13 23:11:12 -04:00
@target_identity_required
def unmute(request: AuthedHttpRequest, user_name):
2023-07-07 16:54:15 -04:00
if request.method != "POST":
raise BadRequest()
2023-08-13 23:11:12 -04:00
request.user.identity.unmute(request.target_identity)
return render(
request,
"users/profile_actions.html",
context={"identity": request.target_identity},
)
2023-07-07 16:54:15 -04:00
@login_required
2023-08-13 23:11:12 -04:00
@target_identity_required
def block(request: AuthedHttpRequest, user_name):
2023-07-07 16:54:15 -04:00
if request.method != "POST":
raise BadRequest()
2023-08-13 23:11:12 -04:00
request.user.identity.block(request.target_identity)
return render(
request,
"users/profile_actions.html",
context={"identity": request.target_identity},
)
2023-07-07 16:54:15 -04:00
@login_required
2023-08-13 23:11:12 -04:00
def unblock(request: AuthedHttpRequest, user_name):
2023-07-07 16:54:15 -04:00
if request.method != "POST":
raise BadRequest()
2023-12-05 22:00:35 -05:00
try:
target = APIdentity.get_by_handler(user_name)
except APIdentity.DoesNotExist:
return render_user_not_found(request)
target_user = target.user
if target_user and not target_user.is_active:
return render_user_not_found(request)
request.user.identity.unblock(target)
2023-08-13 23:11:12 -04:00
return render(
request,
"users/profile_actions.html",
2023-12-05 22:00:35 -05:00
context={"identity": target},
2023-08-13 23:11:12 -04:00
)
@login_required
@target_identity_required
def accept_follow_request(request: AuthedHttpRequest, user_name):
if request.method != "POST":
2023-07-07 02:02:48 -04:00
raise BadRequest()
2023-08-13 23:11:12 -04:00
request.user.identity.accept_follow_request(request.target_identity)
return render(
request,
"users/profile_actions.html",
context={"identity": request.target_identity},
)
2023-07-07 02:02:48 -04:00
@login_required
2023-08-13 23:11:12 -04:00
@target_identity_required
def reject_follow_request(request: AuthedHttpRequest, user_name):
if request.method != "POST":
raise BadRequest()
request.user.identity.reject_follow_request(request.target_identity)
return render(
request,
"users/profile_actions.html",
context={"identity": request.target_identity},
)
2023-07-07 02:02:48 -04:00
2021-02-17 15:08:16 +01:00
@login_required
2023-08-13 23:11:12 -04:00
def set_layout(request: AuthedHttpRequest):
if request.method == "POST":
2023-08-13 23:11:12 -04:00
layout = json.loads(request.POST.get("layout", {})) # type: ignore
2023-04-19 22:31:27 -04:00
if request.POST.get("name") == "profile":
request.user.preference.profile_layout = layout
request.user.preference.save(update_fields=["profile_layout"])
return redirect(request.user.url)
2023-04-19 22:31:27 -04:00
elif request.POST.get("name") == "discover":
request.user.preference.discover_layout = layout
request.user.preference.save(update_fields=["discover_layout"])
return redirect(reverse("catalog:discover"))
raise BadRequest()
2021-02-17 15:08:16 +01:00
2021-02-15 21:27:50 +01:00
2020-05-05 23:50:48 +08:00
@login_required
2023-08-13 23:11:12 -04:00
def report(request: AuthedHttpRequest):
if request.method == "GET":
user_id = request.GET.get("user_id")
2020-05-07 18:00:39 +08:00
if user_id:
user = get_object_or_404(User, pk=user_id)
form = ReportForm(initial={"reported_user": user})
2020-05-07 18:00:39 +08:00
else:
form = ReportForm()
2020-05-05 23:50:48 +08:00
return render(
request,
"users/report.html",
2020-05-05 23:50:48 +08:00
{
"form": form,
},
2020-05-05 23:50:48 +08:00
)
elif request.method == "POST":
form = ReportForm(request.POST, request.FILES)
2020-05-05 23:50:48 +08:00
if form.is_valid():
form.instance.is_read = False
form.instance.submit_user = request.user
form.save()
dw = settings.DISCORD_WEBHOOKS.get("user-report")
if dw:
webhook = SyncWebhook.from_url(dw) # type: ignore
webhook.send(
f"New report from {request.user} about {form.instance.reported_user} : {form.instance.message}"
)
return redirect(reverse("common:home"))
2020-05-05 23:50:48 +08:00
else:
return render(
request,
"users/report.html",
2020-05-05 23:50:48 +08:00
{
"form": form,
},
2020-05-05 23:50:48 +08:00
)
else:
2023-02-04 00:45:17 -05:00
raise BadRequest()
2020-05-05 23:50:48 +08:00
@login_required
2023-08-13 23:11:12 -04:00
def manage_report(request: AuthedHttpRequest):
if not request.user.is_staff:
raise PermissionDenied()
if request.method == "GET":
2020-05-05 23:50:48 +08:00
reports = Report.objects.all()
for r in reports.filter(is_read=False):
2020-07-03 15:36:23 +08:00
r.is_read = True
2020-05-05 23:50:48 +08:00
r.save()
return render(
request,
"users/manage_report.html",
2020-05-05 23:50:48 +08:00
{
"reports": reports,
},
2020-05-05 23:50:48 +08:00
)
else:
2023-02-04 00:45:17 -05:00
raise BadRequest()
@login_required
2023-08-13 23:11:12 -04:00
def mark_announcements_read(request: AuthedHttpRequest):
if request.method == "POST":
try:
request.user.read_announcement_index = Announcement.objects.latest("pk").pk
request.user.save(update_fields=["read_announcement_index"])
except ObjectDoesNotExist:
# when there is no annoucenment
pass
2023-08-13 23:11:12 -04:00
return HttpResponseRedirect(request.META.get("HTTP_REFERER", "/"))