2020-05-05 23:50:48 +08:00
|
|
|
|
from django.shortcuts import reverse, redirect, render, get_object_or_404
|
2020-05-01 22:46:15 +08:00
|
|
|
|
from django.http import HttpResponseBadRequest, HttpResponse
|
2020-05-05 23:50:48 +08:00
|
|
|
|
from django.contrib.auth.decorators import login_required
|
2020-05-01 22:46:15 +08:00
|
|
|
|
from django.contrib import auth
|
|
|
|
|
from django.contrib.auth import authenticate
|
2020-05-05 23:50:48 +08:00
|
|
|
|
from django.core.paginator import Paginator
|
|
|
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
|
|
from django.core.exceptions import ObjectDoesNotExist
|
2020-07-10 21:28:09 +08:00
|
|
|
|
from django.db.models import Count
|
2021-02-17 15:08:16 +01:00
|
|
|
|
from .models import User, Report, Preference
|
2020-05-05 23:50:48 +08:00
|
|
|
|
from .forms import ReportForm
|
2020-10-22 21:45:05 +02:00
|
|
|
|
from mastodon.auth import *
|
|
|
|
|
from mastodon.api import *
|
|
|
|
|
from mastodon import mastodon_request_included
|
2021-02-25 19:43:43 +01:00
|
|
|
|
from common.config import *
|
2020-05-05 23:50:48 +08:00
|
|
|
|
from common.models import MarkStatusEnum
|
2020-07-03 15:36:23 +08:00
|
|
|
|
from common.utils import PageLinksGenerator
|
2021-02-25 19:43:43 +01:00
|
|
|
|
from management.models import Announcement
|
2020-05-05 23:50:48 +08:00
|
|
|
|
from books.models import *
|
2020-10-03 23:27:41 +02:00
|
|
|
|
from movies.models import *
|
2021-02-15 21:27:50 +01:00
|
|
|
|
from music.models import *
|
2021-02-25 19:43:43 +01:00
|
|
|
|
from games.models import *
|
2020-05-08 13:56:58 +08:00
|
|
|
|
from books.forms import BookMarkStatusTranslator
|
2020-10-03 23:27:41 +02:00
|
|
|
|
from movies.forms import MovieMarkStatusTranslator
|
2021-02-15 21:27:50 +01:00
|
|
|
|
from music.forms import MusicMarkStatusTranslator
|
2021-02-25 19:43:43 +01:00
|
|
|
|
from games.forms import GameMarkStatusTranslator
|
2020-10-22 21:45:05 +02:00
|
|
|
|
from mastodon.models import MastodonApplication
|
2022-02-05 18:10:09 -05:00
|
|
|
|
from mastodon.api import verify_account
|
2021-09-10 20:24:22 -04:00
|
|
|
|
from django.conf import settings
|
2021-09-18 10:48:11 -04:00
|
|
|
|
from urllib.parse import quote
|
2021-12-11 09:43:31 -05:00
|
|
|
|
import django_rq
|
|
|
|
|
from .export import *
|
2021-12-15 21:54:24 -05:00
|
|
|
|
from datetime import timedelta
|
|
|
|
|
from django.utils import timezone
|
|
|
|
|
import json
|
2021-12-21 21:25:41 -05:00
|
|
|
|
from django.contrib import messages
|
2021-12-21 23:34:36 -05:00
|
|
|
|
from books.models import BookMark, BookReview
|
|
|
|
|
from movies.models import MovieMark, MovieReview
|
|
|
|
|
from games.models import GameMark, GameReview
|
|
|
|
|
from music.models import AlbumMark, SongMark, AlbumReview, SongReview
|
2021-12-26 15:55:16 -05:00
|
|
|
|
from collection.models import Collection
|
2021-12-11 09:43:31 -05:00
|
|
|
|
|
2020-05-01 22:46:15 +08:00
|
|
|
|
|
|
|
|
|
# Views
|
|
|
|
|
########################################
|
2022-04-01 03:07:56 -04:00
|
|
|
|
def swap_login(request, token, site, refresh_token):
|
2022-02-05 18:10:09 -05:00
|
|
|
|
del request.session['swap_login']
|
|
|
|
|
del request.session['swap_domain']
|
|
|
|
|
code, data = verify_account(site, token)
|
|
|
|
|
current_user = request.user
|
|
|
|
|
if code == 200 and data is not None:
|
|
|
|
|
username = data['username']
|
|
|
|
|
if username == current_user.username and site == current_user.mastodon_site:
|
|
|
|
|
messages.add_message(request, messages.ERROR, _(f'该身份 {username}@{site} 与当前账号相同。'))
|
|
|
|
|
else:
|
|
|
|
|
try:
|
|
|
|
|
existing_user = User.objects.get(username=username, mastodon_site=site)
|
|
|
|
|
messages.add_message(request, messages.ERROR, _(f'该身份 {username}@{site} 已被用于其它账号。'))
|
|
|
|
|
except ObjectDoesNotExist:
|
|
|
|
|
current_user.username = username
|
2022-04-01 03:07:56 -04:00
|
|
|
|
current_user.mastodon_id = data['id']
|
2022-02-05 18:10:09 -05:00
|
|
|
|
current_user.mastodon_site = site
|
|
|
|
|
current_user.mastodon_token = token
|
2022-04-01 03:07:56 -04:00
|
|
|
|
current_user.mastodon_refresh_token = refresh_token
|
|
|
|
|
current_user.mastodon_account = data
|
|
|
|
|
current_user.save(update_fields=['username', 'mastodon_id', 'mastodon_site', 'mastodon_token', 'mastodon_refresh_token', 'mastodon_account'])
|
2022-02-05 18:10:09 -05:00
|
|
|
|
django_rq.get_queue('mastodon').enqueue(refresh_mastodon_data_task, current_user, token)
|
|
|
|
|
messages.add_message(request, messages.INFO, _(f'账号身份已更新为 {username}@{site}。'))
|
|
|
|
|
else:
|
|
|
|
|
messages.add_message(request, messages.ERROR, _('连接联邦网络获取身份信息失败。'))
|
|
|
|
|
return redirect(reverse('users:data'))
|
|
|
|
|
|
2020-05-01 22:46:15 +08:00
|
|
|
|
|
|
|
|
|
# no page rendered
|
2020-05-05 23:50:48 +08:00
|
|
|
|
@mastodon_request_included
|
2020-05-01 22:46:15 +08:00
|
|
|
|
def OAuth2_login(request):
|
|
|
|
|
""" oauth authentication and logging user into django system """
|
|
|
|
|
if request.method == 'GET':
|
|
|
|
|
code = request.GET.get('code')
|
2020-10-22 21:45:05 +02:00
|
|
|
|
site = request.COOKIES.get('mastodon_domain')
|
|
|
|
|
|
2020-05-01 22:46:15 +08:00
|
|
|
|
# Network IO
|
2020-10-25 23:40:58 +01:00
|
|
|
|
try:
|
2022-04-01 03:07:56 -04:00
|
|
|
|
token, refresh_token = obtain_token(site, request, code)
|
2020-10-25 23:40:58 +01:00
|
|
|
|
except ObjectDoesNotExist:
|
|
|
|
|
return HttpResponseBadRequest("Mastodon site not registered")
|
2020-05-01 22:46:15 +08:00
|
|
|
|
if token:
|
2022-02-05 18:10:09 -05:00
|
|
|
|
if request.session.get('swap_login', False) and request.user.is_authenticated: # swap login for existing user
|
2022-04-01 03:07:56 -04:00
|
|
|
|
return swap_login(request, token, site, refresh_token)
|
2020-10-22 21:45:05 +02:00
|
|
|
|
user = authenticate(request, token=token, site=site)
|
2020-05-01 22:46:15 +08:00
|
|
|
|
if user:
|
|
|
|
|
auth_login(request, user, token)
|
2021-02-23 17:29:57 +01:00
|
|
|
|
if request.session.get('next_url') is not None:
|
|
|
|
|
response = redirect(request.session.get('next_url'))
|
|
|
|
|
del request.session['next_url']
|
|
|
|
|
else:
|
|
|
|
|
response = redirect(reverse('common:home'))
|
2021-12-16 08:59:06 -05:00
|
|
|
|
|
2020-10-22 21:45:05 +02:00
|
|
|
|
response.delete_cookie('mastodon_domain')
|
|
|
|
|
return response
|
2020-05-01 22:46:15 +08:00
|
|
|
|
else:
|
|
|
|
|
# will be passed to register page
|
|
|
|
|
request.session['new_user_token'] = token
|
2022-04-01 03:07:56 -04:00
|
|
|
|
request.session['new_user_refresh_token'] = refresh_token
|
2020-05-01 22:46:15 +08:00
|
|
|
|
return redirect(reverse('users:register'))
|
|
|
|
|
else:
|
2020-05-12 14:05:12 +08:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': _("认证失败😫")
|
|
|
|
|
}
|
|
|
|
|
)
|
2020-05-01 22:46:15 +08:00
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# the 'login' page that user can see
|
|
|
|
|
def login(request):
|
|
|
|
|
if request.method == 'GET':
|
2020-10-22 21:45:05 +02:00
|
|
|
|
selected_site = request.GET.get('site', default='')
|
2020-07-05 14:15:36 +08:00
|
|
|
|
|
2020-10-22 21:45:05 +02:00
|
|
|
|
sites = MastodonApplication.objects.all().order_by("domain_name")
|
2020-05-01 22:46:15 +08:00
|
|
|
|
|
2021-02-23 17:29:57 +01:00
|
|
|
|
# store redirect url in the cookie
|
|
|
|
|
if request.GET.get('next'):
|
|
|
|
|
request.session['next_url'] = request.GET.get('next')
|
|
|
|
|
|
2020-05-01 22:46:15 +08:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'users/login.html',
|
|
|
|
|
{
|
2020-10-22 21:45:05 +02:00
|
|
|
|
'sites': sites,
|
2021-09-18 10:48:11 -04:00
|
|
|
|
'scope': quote(settings.MASTODON_CLIENT_SCOPE),
|
2020-10-22 21:45:05 +02:00
|
|
|
|
'selected_site': selected_site,
|
2021-09-10 20:24:22 -04:00
|
|
|
|
'allow_any_site': settings.MASTODON_ALLOW_ANY_SITE,
|
2020-05-01 22:46:15 +08:00
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
2022-01-06 04:22:12 +00:00
|
|
|
|
|
2021-09-10 20:24:22 -04:00
|
|
|
|
def connect(request):
|
2021-09-18 12:09:45 -04:00
|
|
|
|
if not settings.MASTODON_ALLOW_ANY_SITE:
|
|
|
|
|
return redirect(reverse("users:login"))
|
2022-02-05 18:10:09 -05:00
|
|
|
|
login_domain = request.session['swap_domain'] if request.session.get('swap_login') else request.GET.get('domain')
|
|
|
|
|
login_domain = login_domain.strip().lower().split('//')[-1].split('/')[0].split('@')[-1]
|
2022-01-06 04:22:12 +00:00
|
|
|
|
domain = get_instance_domain(login_domain)
|
2022-04-01 03:07:56 -04:00
|
|
|
|
app, error_msg = get_mastodon_application(domain)
|
2021-09-10 20:24:22 -04:00
|
|
|
|
if app is None:
|
2022-04-01 03:07:56 -04:00
|
|
|
|
return render(request, 'common/error.html', {'msg': error_msg, 'secondary_msg': "", })
|
2021-09-10 20:24:22 -04:00
|
|
|
|
else:
|
2022-04-01 03:07:56 -04:00
|
|
|
|
login_url = get_mastodon_login_url(app, login_domain, request)
|
2021-09-14 08:46:37 -04:00
|
|
|
|
resp = redirect(login_url)
|
|
|
|
|
resp.set_cookie("mastodon_domain", domain)
|
|
|
|
|
return resp
|
2020-05-01 22:46:15 +08:00
|
|
|
|
|
2022-02-05 18:10:09 -05:00
|
|
|
|
|
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
|
|
|
|
def reconnect(request):
|
|
|
|
|
if request.method == 'POST':
|
|
|
|
|
request.session['swap_login'] = True
|
|
|
|
|
request.session['swap_domain'] = request.POST['domain']
|
|
|
|
|
return connect(request)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
|
2020-05-05 23:50:48 +08:00
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
2020-05-01 22:46:15 +08:00
|
|
|
|
def logout(request):
|
|
|
|
|
if request.method == 'GET':
|
2022-01-01 17:11:16 +00:00
|
|
|
|
# revoke_token(request.user.mastodon_site, request.session['oauth_token'])
|
2020-05-01 22:46:15 +08:00
|
|
|
|
auth_logout(request)
|
|
|
|
|
return redirect(reverse("users:login"))
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
|
2020-05-05 23:50:48 +08:00
|
|
|
|
@mastodon_request_included
|
2020-05-01 22:46:15 +08:00
|
|
|
|
def register(request):
|
|
|
|
|
""" register confirm page """
|
|
|
|
|
if request.method == 'GET':
|
|
|
|
|
if request.session.get('oauth_token'):
|
|
|
|
|
return redirect(reverse('common:home'))
|
|
|
|
|
elif request.session.get('new_user_token'):
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'users/register.html'
|
|
|
|
|
)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
elif request.method == 'POST':
|
|
|
|
|
token = request.session['new_user_token']
|
2022-04-01 03:07:56 -04:00
|
|
|
|
refresh_token = request.session['new_user_refresh_token']
|
|
|
|
|
code, user_data = verify_account(request.COOKIES['mastodon_domain'], token)
|
|
|
|
|
if code != 200 or user_data is None:
|
2021-02-12 19:23:23 +01:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
2022-02-13 17:00:55 -05:00
|
|
|
|
'msg': _("联邦网络访问失败😫")
|
2021-02-12 19:23:23 +01:00
|
|
|
|
}
|
|
|
|
|
)
|
2020-05-01 22:46:15 +08:00
|
|
|
|
new_user = User(
|
|
|
|
|
username=user_data['username'],
|
2020-10-22 21:45:05 +02:00
|
|
|
|
mastodon_id=user_data['id'],
|
|
|
|
|
mastodon_site=request.COOKIES['mastodon_domain'],
|
2022-04-01 03:07:56 -04:00
|
|
|
|
mastodon_token=token,
|
|
|
|
|
mastodon_refresh_token=refresh_token,
|
|
|
|
|
mastodon_account=user_data,
|
2020-05-01 22:46:15 +08:00
|
|
|
|
)
|
|
|
|
|
new_user.save()
|
|
|
|
|
del request.session['new_user_token']
|
2022-04-01 03:07:56 -04:00
|
|
|
|
del request.session['new_user_refresh_token']
|
2020-05-01 22:46:15 +08:00
|
|
|
|
auth_login(request, new_user, token)
|
2020-10-22 21:45:05 +02:00
|
|
|
|
response = redirect(reverse('common:home'))
|
|
|
|
|
response.delete_cookie('mastodon_domain')
|
|
|
|
|
return response
|
2020-05-01 22:46:15 +08:00
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def delete(request):
|
|
|
|
|
raise NotImplementedError
|
|
|
|
|
|
2021-09-25 23:18:03 -04:00
|
|
|
|
def home_anonymous(request, id):
|
|
|
|
|
login_url = settings.LOGIN_URL + "?next=" + request.get_full_path()
|
|
|
|
|
try:
|
|
|
|
|
username = id.split('@')[0]
|
|
|
|
|
site = id.split('@')[1]
|
|
|
|
|
return render(request, 'users/home_anonymous.html', {
|
|
|
|
|
'login_url': login_url,
|
|
|
|
|
'username': username,
|
|
|
|
|
'site': site,
|
|
|
|
|
})
|
2021-10-11 22:05:30 -04:00
|
|
|
|
except Exception:
|
2021-09-25 23:18:03 -04:00
|
|
|
|
return redirect(login_url)
|
2020-05-01 22:46:15 +08:00
|
|
|
|
|
2020-05-05 23:50:48 +08:00
|
|
|
|
@mastodon_request_included
|
|
|
|
|
def home(request, id):
|
2021-09-25 23:18:03 -04:00
|
|
|
|
if not request.user.is_authenticated:
|
|
|
|
|
return home_anonymous(request, id)
|
2020-05-05 23:50:48 +08:00
|
|
|
|
if request.method == 'GET':
|
2020-10-22 21:45:05 +02:00
|
|
|
|
if isinstance(id, str):
|
|
|
|
|
try:
|
|
|
|
|
username = id.split('@')[0]
|
|
|
|
|
site = id.split('@')[1]
|
|
|
|
|
except IndexError as e:
|
|
|
|
|
return HttpResponseBadRequest("Invalid user id")
|
|
|
|
|
query_kwargs = {'username': username, 'mastodon_site': site}
|
|
|
|
|
elif isinstance(id, int):
|
2020-05-05 23:50:48 +08:00
|
|
|
|
query_kwargs = {'pk': id}
|
|
|
|
|
try:
|
|
|
|
|
user = User.objects.get(**query_kwargs)
|
|
|
|
|
except ObjectDoesNotExist:
|
2022-02-13 17:00:55 -05:00
|
|
|
|
msg = _("😖哎呀,这位用户还没有加入本站,快去联邦宇宙呼唤TA来注册吧!")
|
|
|
|
|
sec_msg = _("目前支持来自Mastodon和Pleroma实例的用户注册")
|
2020-05-05 23:50:48 +08:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
'secondary_msg': sec_msg,
|
|
|
|
|
}
|
|
|
|
|
)
|
2021-02-25 19:43:43 +01:00
|
|
|
|
|
|
|
|
|
# access one's own home page
|
2020-05-05 23:50:48 +08:00
|
|
|
|
if user == request.user:
|
2021-02-25 19:43:43 +01:00
|
|
|
|
reports = Report.objects.order_by(
|
|
|
|
|
'-submitted_time').filter(is_read=False)
|
|
|
|
|
unread_announcements = Announcement.objects.filter(
|
|
|
|
|
pk__gt=request.user.read_announcement_index).order_by('-pk')
|
|
|
|
|
try:
|
|
|
|
|
request.user.read_announcement_index = Announcement.objects.latest(
|
|
|
|
|
'pk').pk
|
|
|
|
|
request.user.save(update_fields=['read_announcement_index'])
|
|
|
|
|
except ObjectDoesNotExist as e:
|
|
|
|
|
# when there is no annoucenment
|
|
|
|
|
pass
|
|
|
|
|
book_marks = request.user.user_bookmarks.all()
|
|
|
|
|
movie_marks = request.user.user_moviemarks.all()
|
|
|
|
|
album_marks = request.user.user_albummarks.all()
|
|
|
|
|
song_marks = request.user.user_songmarks.all()
|
|
|
|
|
game_marks = request.user.user_gamemarks.all()
|
2021-12-16 22:38:34 -05:00
|
|
|
|
book_reviews = request.user.user_bookreviews.all()
|
|
|
|
|
movie_reviews = request.user.user_moviereviews.all()
|
|
|
|
|
album_reviews = request.user.user_albumreviews.all()
|
|
|
|
|
song_reviews = request.user.user_songreviews.all()
|
|
|
|
|
game_reviews = request.user.user_gamereviews.all()
|
2021-02-25 19:43:43 +01:00
|
|
|
|
|
2021-06-14 22:18:39 +02:00
|
|
|
|
latest_task = user.user_synctasks.order_by("-id").first()
|
|
|
|
|
|
2021-02-25 19:43:43 +01:00
|
|
|
|
# visit other's home page
|
2020-05-05 23:50:48 +08:00
|
|
|
|
else:
|
2021-06-14 23:47:36 +02:00
|
|
|
|
latest_task = None
|
2021-02-25 19:43:43 +01:00
|
|
|
|
# no these value on other's home page
|
|
|
|
|
reports = None
|
|
|
|
|
unread_announcements = None
|
|
|
|
|
|
|
|
|
|
# cross site info for visiting other's home page
|
|
|
|
|
user.target_site_id = get_cross_site_id(
|
|
|
|
|
user, request.user.mastodon_site, request.session['oauth_token'])
|
2021-12-16 08:59:06 -05:00
|
|
|
|
|
2021-02-25 19:43:43 +01:00
|
|
|
|
# make queries
|
2020-10-22 21:45:05 +02:00
|
|
|
|
relation = get_relationship(request.user, user, request.session['oauth_token'])[0]
|
2020-05-05 23:50:48 +08:00
|
|
|
|
if relation['blocked_by']:
|
|
|
|
|
msg = _("你没有访问TA主页的权限😥")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
}
|
|
|
|
|
)
|
2020-11-28 16:38:07 +01:00
|
|
|
|
book_marks = BookMark.get_available_by_user(user, relation['following'])
|
2021-02-25 19:43:43 +01:00
|
|
|
|
movie_marks = MovieMark.get_available_by_user(user, relation['following'])
|
|
|
|
|
song_marks = SongMark.get_available_by_user(user, relation['following'])
|
|
|
|
|
album_marks = AlbumMark.get_available_by_user(user, relation['following'])
|
|
|
|
|
game_marks = GameMark.get_available_by_user(user, relation['following'])
|
2021-12-17 21:27:56 +00:00
|
|
|
|
book_reviews = BookReview.get_available_by_user(user, relation['following'])
|
|
|
|
|
movie_reviews = MovieReview.get_available_by_user(user, relation['following'])
|
|
|
|
|
song_reviews = SongReview.get_available_by_user(user, relation['following'])
|
|
|
|
|
album_reviews = AlbumReview.get_available_by_user(user, relation['following'])
|
|
|
|
|
game_reviews = GameReview.get_available_by_user(user, relation['following'])
|
2020-05-05 23:50:48 +08:00
|
|
|
|
|
2021-12-26 15:55:16 -05:00
|
|
|
|
collections = Collection.objects.filter(owner=user)
|
2021-02-25 19:43:43 +01:00
|
|
|
|
# book marks
|
2021-12-16 08:59:06 -05:00
|
|
|
|
filtered_book_marks = filter_marks(book_marks, BOOKS_PER_SET, 'book')
|
2021-04-25 11:18:36 +02:00
|
|
|
|
book_marks_count = count_marks(book_marks, "book")
|
2020-10-03 23:27:41 +02:00
|
|
|
|
|
2021-02-25 19:43:43 +01:00
|
|
|
|
# movie marks
|
|
|
|
|
filtered_movie_marks = filter_marks(movie_marks, MOVIES_PER_SET, 'movie')
|
2021-04-25 11:18:36 +02:00
|
|
|
|
movie_marks_count= count_marks(movie_marks, "movie")
|
2020-10-03 23:27:41 +02:00
|
|
|
|
|
2021-02-25 19:43:43 +01:00
|
|
|
|
# game marks
|
|
|
|
|
filtered_game_marks = filter_marks(game_marks, GAMES_PER_SET, 'game')
|
2021-04-25 11:18:36 +02:00
|
|
|
|
game_marks_count = count_marks(game_marks, "game")
|
2021-02-17 15:08:16 +01:00
|
|
|
|
|
2021-02-25 19:43:43 +01:00
|
|
|
|
# music marks
|
2021-04-25 11:18:36 +02:00
|
|
|
|
filtered_music_marks = filter_marks([song_marks, album_marks], MUSIC_PER_SET, 'music')
|
|
|
|
|
music_marks_count = count_marks([song_marks, album_marks], "music")
|
2021-12-16 08:59:06 -05:00
|
|
|
|
|
2021-04-25 11:18:36 +02:00
|
|
|
|
for mark in filtered_music_marks["do_music_marks"] +\
|
|
|
|
|
filtered_music_marks["wish_music_marks"] +\
|
|
|
|
|
filtered_music_marks["collect_music_marks"]:
|
2021-02-25 19:43:43 +01:00
|
|
|
|
# for template convenience
|
|
|
|
|
if mark.__class__ == AlbumMark:
|
|
|
|
|
mark.type = "album"
|
|
|
|
|
else:
|
|
|
|
|
mark.type = "song"
|
2021-12-16 08:59:06 -05:00
|
|
|
|
|
2021-12-16 22:38:34 -05:00
|
|
|
|
music_reviews = list(album_reviews.order_by("-edited_time")) + list(song_reviews.order_by("-edited_time"))
|
|
|
|
|
for review in music_reviews:
|
|
|
|
|
review.type = 'album' if review.__class__ == AlbumReview else 'song'
|
|
|
|
|
|
2021-02-25 19:43:43 +01:00
|
|
|
|
try:
|
|
|
|
|
layout = user.preference.get_serialized_home_layout()
|
|
|
|
|
except ObjectDoesNotExist:
|
|
|
|
|
Preference.objects.create(user=user)
|
|
|
|
|
layout = user.preference.get_serialized_home_layout()
|
2021-02-17 15:08:16 +01:00
|
|
|
|
|
2021-02-25 19:43:43 +01:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'users/home.html',
|
|
|
|
|
{
|
|
|
|
|
'user': user,
|
|
|
|
|
**filtered_book_marks,
|
|
|
|
|
**filtered_movie_marks,
|
|
|
|
|
**filtered_game_marks,
|
2021-04-25 11:18:36 +02:00
|
|
|
|
**filtered_music_marks,
|
|
|
|
|
**book_marks_count,
|
|
|
|
|
**movie_marks_count,
|
|
|
|
|
**music_marks_count,
|
|
|
|
|
**game_marks_count,
|
2021-12-16 22:38:34 -05:00
|
|
|
|
|
2022-01-16 18:01:26 -05:00
|
|
|
|
'book_tags': list(map(lambda t: t['content'], BookTag.all_by_user(user)))[:10] if user == request.user else [],
|
|
|
|
|
'movie_tags': list(map(lambda t: t['content'], MovieTag.all_by_user(user)))[:10] if user == request.user else [],
|
|
|
|
|
'music_tags': list(map(lambda t: t['content'], AlbumTag.all_by_user(user)))[:10] if user == request.user else [],
|
|
|
|
|
'game_tags': list(map(lambda t: t['content'], GameTag.all_by_user(user)))[:10] if user == request.user else [],
|
|
|
|
|
|
2021-12-16 22:38:34 -05:00
|
|
|
|
'book_reviews': book_reviews.order_by("-edited_time")[:BOOKS_PER_SET],
|
|
|
|
|
'movie_reviews': movie_reviews.order_by("-edited_time")[:MOVIES_PER_SET],
|
|
|
|
|
'music_reviews': music_reviews[:MUSIC_PER_SET],
|
|
|
|
|
'game_reviews': game_reviews[:GAMES_PER_SET],
|
|
|
|
|
'book_reviews_more': book_reviews.count() > BOOKS_PER_SET,
|
|
|
|
|
'movie_reviews_more': movie_reviews.count() > MOVIES_PER_SET,
|
|
|
|
|
'music_reviews_more': len(music_reviews) > MUSIC_PER_SET,
|
|
|
|
|
'game_reviews_more': game_reviews.count() > GAMES_PER_SET,
|
|
|
|
|
'book_reviews_count': book_reviews.count(),
|
|
|
|
|
'movie_reviews_count': movie_reviews.count(),
|
|
|
|
|
'music_reviews_count': len(music_reviews),
|
|
|
|
|
'game_reviews_count': game_reviews.count(),
|
|
|
|
|
|
2021-12-26 15:55:16 -05:00
|
|
|
|
'collections': collections.order_by("-edited_time")[:BOOKS_PER_SET],
|
|
|
|
|
'collections_count': collections.count(),
|
|
|
|
|
'collections_more': collections.count() > BOOKS_PER_SET,
|
|
|
|
|
|
2021-02-25 19:43:43 +01:00
|
|
|
|
'layout': layout,
|
|
|
|
|
'reports': reports,
|
|
|
|
|
'unread_announcements': unread_announcements,
|
2021-06-14 22:18:39 +02:00
|
|
|
|
'latest_task': latest_task,
|
2021-02-25 19:43:43 +01:00
|
|
|
|
}
|
|
|
|
|
)
|
2020-05-05 23:50:48 +08:00
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
|
2021-04-25 11:18:36 +02:00
|
|
|
|
def filter_marks(querysets, maximum, type_name):
|
|
|
|
|
"""
|
2021-12-16 08:59:06 -05:00
|
|
|
|
Filter marks by amount limits and order them edited time, store results in a dict,
|
2021-04-25 11:18:36 +02:00
|
|
|
|
which could be directly used in template.
|
|
|
|
|
@param querysets: one queryset or multiple querysets as a list
|
|
|
|
|
"""
|
2021-02-25 19:43:43 +01:00
|
|
|
|
result = {}
|
2021-04-25 11:18:36 +02:00
|
|
|
|
if not isinstance(querysets, list):
|
|
|
|
|
querysets = [querysets]
|
|
|
|
|
|
|
|
|
|
for status in MarkStatusEnum.values:
|
|
|
|
|
marks = []
|
|
|
|
|
count = 0
|
|
|
|
|
for queryset in querysets:
|
2021-04-25 13:03:09 +02:00
|
|
|
|
marks += list(queryset.filter(status=MarkStatusEnum[status.upper()]).order_by("-edited_time")[:maximum])
|
2021-04-25 11:18:36 +02:00
|
|
|
|
count += queryset.filter(status=MarkStatusEnum[status.upper()]).count()
|
2021-12-16 08:59:06 -05:00
|
|
|
|
|
2021-04-25 11:18:36 +02:00
|
|
|
|
# marks
|
|
|
|
|
marks = sorted(marks, key=lambda e: e.edited_time, reverse=True)[:maximum]
|
|
|
|
|
result[f"{status}_{type_name}_marks"] = marks
|
|
|
|
|
# flag indicates if marks are more than `maximun`
|
|
|
|
|
if count > maximum:
|
|
|
|
|
result[f"{status}_{type_name}_more"] = True
|
2021-02-25 19:43:43 +01:00
|
|
|
|
else:
|
2021-04-25 11:18:36 +02:00
|
|
|
|
result[f"{status}_{type_name}_more"] = False
|
|
|
|
|
|
|
|
|
|
return result
|
|
|
|
|
|
|
|
|
|
def count_marks(querysets, type_name):
|
|
|
|
|
"""
|
|
|
|
|
Count all available marks, then assembly a dict to be used in template
|
|
|
|
|
@param querysets: one queryset or multiple querysets as a list
|
|
|
|
|
"""
|
|
|
|
|
result = {}
|
|
|
|
|
if not isinstance(querysets, list):
|
|
|
|
|
querysets = [querysets]
|
|
|
|
|
for status in MarkStatusEnum.values:
|
|
|
|
|
count = 0
|
|
|
|
|
for queryset in querysets:
|
|
|
|
|
count += queryset.filter(status=MarkStatusEnum[status.upper()]).count()
|
|
|
|
|
result[f"{status}_{type_name}_count"] = count
|
2021-02-25 19:43:43 +01:00
|
|
|
|
return result
|
|
|
|
|
|
|
|
|
|
|
2020-05-05 23:50:48 +08:00
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
2021-12-16 08:59:06 -05:00
|
|
|
|
def followers(request, id):
|
2020-05-05 23:50:48 +08:00
|
|
|
|
if request.method == 'GET':
|
2020-10-22 21:45:05 +02:00
|
|
|
|
if isinstance(id, str):
|
|
|
|
|
try:
|
|
|
|
|
username = id.split('@')[0]
|
|
|
|
|
site = id.split('@')[1]
|
|
|
|
|
except IndexError as e:
|
|
|
|
|
return HttpResponseBadRequest("Invalid user id")
|
|
|
|
|
query_kwargs = {'username': username, 'mastodon_site': site}
|
|
|
|
|
elif isinstance(id, int):
|
|
|
|
|
query_kwargs = {'pk': id}
|
2020-05-05 23:50:48 +08:00
|
|
|
|
try:
|
2020-10-22 21:45:05 +02:00
|
|
|
|
user = User.objects.get(**query_kwargs)
|
2020-05-05 23:50:48 +08:00
|
|
|
|
except ObjectDoesNotExist:
|
2022-02-13 17:00:55 -05:00
|
|
|
|
msg = _("😖哎呀,这位用户还没有加入本站,快去联邦宇宙呼唤TA来注册吧!")
|
2020-05-05 23:50:48 +08:00
|
|
|
|
sec_msg = _("目前只开放本站用户注册")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
'secondary_msg': sec_msg,
|
|
|
|
|
}
|
2021-12-16 08:59:06 -05:00
|
|
|
|
)
|
2020-05-05 23:50:48 +08:00
|
|
|
|
# mastodon request
|
|
|
|
|
if not user == request.user:
|
2020-10-22 21:45:05 +02:00
|
|
|
|
relation = get_relationship(request.user, user, request.session['oauth_token'])[0]
|
2020-05-05 23:50:48 +08:00
|
|
|
|
if relation['blocked_by']:
|
|
|
|
|
msg = _("你没有访问TA主页的权限😥")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
}
|
|
|
|
|
)
|
2020-10-22 21:45:05 +02:00
|
|
|
|
user.target_site_id = get_cross_site_id(
|
|
|
|
|
user, request.user.mastodon_site, request.session['oauth_token'])
|
2020-05-05 23:50:48 +08:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
2020-07-03 15:36:23 +08:00
|
|
|
|
'users/relation_list.html',
|
2020-05-05 23:50:48 +08:00
|
|
|
|
{
|
|
|
|
|
'user': user,
|
|
|
|
|
'is_followers_page': True,
|
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
|
|
|
|
def following(request, id):
|
|
|
|
|
if request.method == 'GET':
|
2020-10-22 21:45:05 +02:00
|
|
|
|
if isinstance(id, str):
|
|
|
|
|
try:
|
|
|
|
|
username = id.split('@')[0]
|
|
|
|
|
site = id.split('@')[1]
|
|
|
|
|
except IndexError as e:
|
|
|
|
|
return HttpResponseBadRequest("Invalid user id")
|
|
|
|
|
query_kwargs = {'username': username, 'mastodon_site': site}
|
|
|
|
|
elif isinstance(id, int):
|
|
|
|
|
query_kwargs = {'pk': id}
|
2020-05-05 23:50:48 +08:00
|
|
|
|
try:
|
2020-10-22 21:45:05 +02:00
|
|
|
|
user = User.objects.get(**query_kwargs)
|
2020-05-05 23:50:48 +08:00
|
|
|
|
except ObjectDoesNotExist:
|
2022-02-13 17:00:55 -05:00
|
|
|
|
msg = _("😖哎呀,这位用户还没有加入本站,快去联邦宇宙呼唤TA来注册吧!")
|
2020-05-05 23:50:48 +08:00
|
|
|
|
sec_msg = _("目前只开放本站用户注册")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
'secondary_msg': sec_msg,
|
|
|
|
|
}
|
2021-12-16 08:59:06 -05:00
|
|
|
|
)
|
2020-05-05 23:50:48 +08:00
|
|
|
|
# mastodon request
|
|
|
|
|
if not user == request.user:
|
2020-10-22 21:45:05 +02:00
|
|
|
|
relation = get_relationship(request.user, user, request.session['oauth_token'])[0]
|
2020-05-05 23:50:48 +08:00
|
|
|
|
if relation['blocked_by']:
|
|
|
|
|
msg = _("你没有访问TA主页的权限😥")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
}
|
|
|
|
|
)
|
2020-10-22 21:45:05 +02:00
|
|
|
|
user.target_site_id = get_cross_site_id(
|
|
|
|
|
user, request.user.mastodon_site, request.session['oauth_token'])
|
2020-05-05 23:50:48 +08:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
2020-07-03 15:36:23 +08:00
|
|
|
|
'users/relation_list.html',
|
2020-05-05 23:50:48 +08:00
|
|
|
|
{
|
|
|
|
|
'user': user,
|
|
|
|
|
'page_type': 'followers',
|
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
|
|
|
|
def book_list(request, id, status):
|
|
|
|
|
if request.method == 'GET':
|
2022-01-16 18:01:26 -05:00
|
|
|
|
if status.upper() not in MarkStatusEnum.names and status not in ['reviewed', 'tagged']:
|
2020-05-05 23:50:48 +08:00
|
|
|
|
return HttpResponseBadRequest()
|
2021-12-16 08:59:06 -05:00
|
|
|
|
|
2020-10-22 21:45:05 +02:00
|
|
|
|
if isinstance(id, str):
|
|
|
|
|
try:
|
|
|
|
|
username = id.split('@')[0]
|
|
|
|
|
site = id.split('@')[1]
|
|
|
|
|
except IndexError as e:
|
|
|
|
|
return HttpResponseBadRequest("Invalid user id")
|
|
|
|
|
query_kwargs = {'username': username, 'mastodon_site': site}
|
|
|
|
|
elif isinstance(id, int):
|
|
|
|
|
query_kwargs = {'pk': id}
|
2020-05-05 23:50:48 +08:00
|
|
|
|
try:
|
2020-10-22 21:45:05 +02:00
|
|
|
|
user = User.objects.get(**query_kwargs)
|
2020-05-05 23:50:48 +08:00
|
|
|
|
except ObjectDoesNotExist:
|
2022-02-13 17:00:55 -05:00
|
|
|
|
msg = _("😖哎呀,这位用户还没有加入本站,快去联邦宇宙呼唤TA来注册吧!")
|
2020-05-05 23:50:48 +08:00
|
|
|
|
sec_msg = _("目前只开放本站用户注册")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
'secondary_msg': sec_msg,
|
|
|
|
|
}
|
2021-12-16 08:59:06 -05:00
|
|
|
|
)
|
2022-01-16 18:01:26 -05:00
|
|
|
|
tag = request.GET.get('t', default='')
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if user != request.user:
|
2020-05-08 13:56:58 +08:00
|
|
|
|
# mastodon request
|
2020-10-22 21:45:05 +02:00
|
|
|
|
relation = get_relationship(request.user, user, request.session['oauth_token'])[0]
|
2020-05-05 23:50:48 +08:00
|
|
|
|
if relation['blocked_by']:
|
|
|
|
|
msg = _("你没有访问TA主页的权限😥")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
}
|
|
|
|
|
)
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
queryset = BookReview.get_available_by_user(user, relation['following']).order_by("-edited_time")
|
2022-01-16 18:01:26 -05:00
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
queryset = BookTag.find_by_user(tag, user, relation['following']).order_by("-mark__edited_time")
|
2021-12-16 08:59:06 -05:00
|
|
|
|
else:
|
|
|
|
|
queryset = BookMark.get_available_by_user(user, relation['following']).filter(
|
|
|
|
|
status=MarkStatusEnum[status.upper()]).order_by("-edited_time")
|
2020-10-22 21:45:05 +02:00
|
|
|
|
user.target_site_id = get_cross_site_id(
|
|
|
|
|
user, request.user.mastodon_site, request.session['oauth_token'])
|
2020-05-05 23:50:48 +08:00
|
|
|
|
else:
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
queryset = BookReview.objects.filter(owner=user).order_by("-edited_time")
|
2022-01-16 18:01:26 -05:00
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
queryset = BookTag.objects.filter(content=tag, mark__owner=user).order_by("-mark__edited_time")
|
2021-12-16 08:59:06 -05:00
|
|
|
|
else:
|
|
|
|
|
queryset = BookMark.objects.filter(
|
|
|
|
|
owner=user, status=MarkStatusEnum[status.upper()]).order_by("-edited_time")
|
2020-05-05 23:50:48 +08:00
|
|
|
|
paginator = Paginator(queryset, ITEMS_PER_PAGE)
|
|
|
|
|
page_number = request.GET.get('page', default=1)
|
|
|
|
|
marks = paginator.get_page(page_number)
|
2020-07-10 21:28:09 +08:00
|
|
|
|
for mark in marks:
|
|
|
|
|
mark.book.tag_list = mark.book.get_tags_manager().values('content').annotate(
|
|
|
|
|
tag_frequency=Count('content')).order_by('-tag_frequency')[:TAG_NUMBER_ON_LIST]
|
2020-07-03 15:36:23 +08:00
|
|
|
|
marks.pagination = PageLinksGenerator(PAGE_LINK_NUMBER, page_number, paginator.num_pages)
|
2022-01-16 18:01:26 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
list_title = str(_("评论过的书"))
|
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
list_title = str(_(f"标记为「{tag}」的书"))
|
|
|
|
|
else:
|
|
|
|
|
list_title = str(BookMarkStatusTranslator(MarkStatusEnum[status.upper()])) + str(_("的书"))
|
2020-05-05 23:50:48 +08:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
2020-10-04 16:16:50 +02:00
|
|
|
|
'users/book_list.html',
|
2020-05-05 23:50:48 +08:00
|
|
|
|
{
|
|
|
|
|
'marks': marks,
|
|
|
|
|
'user': user,
|
2021-12-16 08:59:06 -05:00
|
|
|
|
'status': status,
|
|
|
|
|
'list_title': list_title,
|
2020-05-05 23:50:48 +08:00
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
2020-10-03 23:27:41 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
|
|
|
|
def movie_list(request, id, status):
|
|
|
|
|
if request.method == 'GET':
|
2022-01-16 18:01:26 -05:00
|
|
|
|
if status.upper() not in MarkStatusEnum.names and status not in ['reviewed', 'tagged']:
|
2020-10-03 23:27:41 +02:00
|
|
|
|
return HttpResponseBadRequest()
|
2020-10-22 21:45:05 +02:00
|
|
|
|
|
|
|
|
|
if isinstance(id, str):
|
|
|
|
|
try:
|
|
|
|
|
username = id.split('@')[0]
|
|
|
|
|
site = id.split('@')[1]
|
|
|
|
|
except IndexError as e:
|
|
|
|
|
return HttpResponseBadRequest("Invalid user id")
|
|
|
|
|
query_kwargs = {'username': username, 'mastodon_site': site}
|
|
|
|
|
elif isinstance(id, int):
|
|
|
|
|
query_kwargs = {'pk': id}
|
2020-10-03 23:27:41 +02:00
|
|
|
|
try:
|
2020-10-22 21:45:05 +02:00
|
|
|
|
user = User.objects.get(**query_kwargs)
|
2020-10-03 23:27:41 +02:00
|
|
|
|
except ObjectDoesNotExist:
|
2022-02-13 17:00:55 -05:00
|
|
|
|
msg = _("😖哎呀,这位用户还没有加入本站,快去联邦宇宙呼唤TA来注册吧!")
|
2020-10-03 23:27:41 +02:00
|
|
|
|
sec_msg = _("目前只开放本站用户注册")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
'secondary_msg': sec_msg,
|
|
|
|
|
}
|
2021-02-25 19:43:43 +01:00
|
|
|
|
)
|
2022-01-16 18:01:26 -05:00
|
|
|
|
tag = request.GET.get('t', default='')
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if user != request.user:
|
2020-10-03 23:27:41 +02:00
|
|
|
|
# mastodon request
|
2020-10-22 21:45:05 +02:00
|
|
|
|
relation = get_relationship(request.user, user, request.session['oauth_token'])[0]
|
2020-10-03 23:27:41 +02:00
|
|
|
|
if relation['blocked_by']:
|
|
|
|
|
msg = _("你没有访问TA主页的权限😥")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
}
|
|
|
|
|
)
|
2020-10-22 21:45:05 +02:00
|
|
|
|
user.target_site_id = get_cross_site_id(
|
|
|
|
|
user, request.user.mastodon_site, request.session['oauth_token'])
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
queryset = MovieReview.get_available_by_user(user, relation['following']).order_by("-edited_time")
|
2022-01-16 18:01:26 -05:00
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
queryset = MovieTag.find_by_user(tag, user, relation['following']).order_by("-mark__edited_time")
|
2021-12-16 08:59:06 -05:00
|
|
|
|
else:
|
|
|
|
|
queryset = MovieMark.get_available_by_user(user, relation['following']).filter(
|
|
|
|
|
status=MarkStatusEnum[status.upper()]).order_by("-edited_time")
|
2020-10-03 23:27:41 +02:00
|
|
|
|
else:
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
queryset = MovieReview.objects.filter(owner=user).order_by("-edited_time")
|
2022-01-16 18:01:26 -05:00
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
queryset = MovieTag.objects.filter(content=tag, mark__owner=user).order_by("-mark__edited_time")
|
2021-12-16 08:59:06 -05:00
|
|
|
|
else:
|
|
|
|
|
queryset = MovieMark.objects.filter(owner=user, status=MarkStatusEnum[status.upper()]).order_by("-edited_time")
|
2020-10-03 23:27:41 +02:00
|
|
|
|
paginator = Paginator(queryset, ITEMS_PER_PAGE)
|
|
|
|
|
page_number = request.GET.get('page', default=1)
|
|
|
|
|
marks = paginator.get_page(page_number)
|
|
|
|
|
for mark in marks:
|
|
|
|
|
mark.movie.tag_list = mark.movie.get_tags_manager().values('content').annotate(
|
|
|
|
|
tag_frequency=Count('content')).order_by('-tag_frequency')[:TAG_NUMBER_ON_LIST]
|
|
|
|
|
marks.pagination = PageLinksGenerator(PAGE_LINK_NUMBER, page_number, paginator.num_pages)
|
2022-01-16 18:01:26 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
list_title = str(_("评论过的电影和剧集"))
|
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
list_title = str(_(f"标记为「{tag}」的电影和剧集"))
|
|
|
|
|
else:
|
|
|
|
|
list_title = str(MovieMarkStatusTranslator(MarkStatusEnum[status.upper()])) + str(_("的电影和剧集"))
|
|
|
|
|
|
2020-10-03 23:27:41 +02:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
2020-10-04 16:16:50 +02:00
|
|
|
|
'users/movie_list.html',
|
2020-10-03 23:27:41 +02:00
|
|
|
|
{
|
|
|
|
|
'marks': marks,
|
|
|
|
|
'user': user,
|
2021-12-16 08:59:06 -05:00
|
|
|
|
'status': status,
|
|
|
|
|
'list_title': list_title,
|
2020-10-03 23:27:41 +02:00
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
2021-12-16 08:59:06 -05:00
|
|
|
|
|
2020-05-05 23:50:48 +08:00
|
|
|
|
|
2021-02-25 19:43:43 +01:00
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
|
|
|
|
def game_list(request, id, status):
|
|
|
|
|
if request.method == 'GET':
|
2022-01-16 18:01:26 -05:00
|
|
|
|
if status.upper() not in MarkStatusEnum.names and status not in ['reviewed', 'tagged']:
|
2021-02-25 19:43:43 +01:00
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
if isinstance(id, str):
|
|
|
|
|
try:
|
|
|
|
|
username = id.split('@')[0]
|
|
|
|
|
site = id.split('@')[1]
|
|
|
|
|
except IndexError as e:
|
|
|
|
|
return HttpResponseBadRequest("Invalid user id")
|
|
|
|
|
query_kwargs = {'username': username, 'mastodon_site': site}
|
|
|
|
|
elif isinstance(id, int):
|
|
|
|
|
query_kwargs = {'pk': id}
|
|
|
|
|
try:
|
|
|
|
|
user = User.objects.get(**query_kwargs)
|
|
|
|
|
except ObjectDoesNotExist:
|
2022-02-13 17:00:55 -05:00
|
|
|
|
msg = _("😖哎呀,这位用户还没有加入本站,快去联邦宇宙呼唤TA来注册吧!")
|
2021-02-25 19:43:43 +01:00
|
|
|
|
sec_msg = _("目前只开放本站用户注册")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
'secondary_msg': sec_msg,
|
|
|
|
|
}
|
|
|
|
|
)
|
2022-01-16 18:01:26 -05:00
|
|
|
|
tag = request.GET.get('t', default='')
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if user != request.user:
|
2021-02-25 19:43:43 +01:00
|
|
|
|
# mastodon request
|
|
|
|
|
relation = get_relationship(request.user, user, request.session['oauth_token'])[0]
|
|
|
|
|
if relation['blocked_by']:
|
|
|
|
|
msg = _("你没有访问TA主页的权限😥")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
user.target_site_id = get_cross_site_id(
|
|
|
|
|
user, request.user.mastodon_site, request.session['oauth_token'])
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
queryset = GameReview.get_available_by_user(user, relation['following']).order_by("-edited_time")
|
2022-01-16 18:01:26 -05:00
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
queryset = GameTag.find_by_user(tag, user, relation['following']).order_by("-mark__edited_time")
|
2021-12-16 08:59:06 -05:00
|
|
|
|
else:
|
|
|
|
|
queryset = GameMark.get_available_by_user(user, relation['following']).filter(
|
|
|
|
|
status=MarkStatusEnum[status.upper()]).order_by("-edited_time")
|
2021-02-25 19:43:43 +01:00
|
|
|
|
else:
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
queryset = GameReview.objects.filter(owner=user).order_by("-edited_time")
|
2022-01-16 18:01:26 -05:00
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
queryset = GameTag.objects.filter(content=tag, mark__owner=user).order_by("-mark__edited_time")
|
2021-12-16 08:59:06 -05:00
|
|
|
|
else:
|
|
|
|
|
queryset = GameMark.objects.filter(
|
|
|
|
|
owner=user, status=MarkStatusEnum[status.upper()]).order_by("-edited_time")
|
2021-02-25 19:43:43 +01:00
|
|
|
|
paginator = Paginator(queryset, ITEMS_PER_PAGE)
|
|
|
|
|
page_number = request.GET.get('page', default=1)
|
|
|
|
|
marks = paginator.get_page(page_number)
|
|
|
|
|
for mark in marks:
|
|
|
|
|
mark.game.tag_list = mark.game.get_tags_manager().values('content').annotate(
|
|
|
|
|
tag_frequency=Count('content')).order_by('-tag_frequency')[:TAG_NUMBER_ON_LIST]
|
|
|
|
|
marks.pagination = PageLinksGenerator(PAGE_LINK_NUMBER, page_number, paginator.num_pages)
|
2022-01-16 18:01:26 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
list_title = str(_("评论过的游戏"))
|
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
list_title = str(_(f"标记为「{tag}」的游戏"))
|
|
|
|
|
else:
|
|
|
|
|
list_title = str(GameMarkStatusTranslator(MarkStatusEnum[status.upper()])) + str(_("的游戏"))
|
2021-02-25 19:43:43 +01:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'users/game_list.html',
|
|
|
|
|
{
|
|
|
|
|
'marks': marks,
|
|
|
|
|
'user': user,
|
2021-12-16 08:59:06 -05:00
|
|
|
|
'status': status,
|
|
|
|
|
'list_title': list_title,
|
2021-02-25 19:43:43 +01:00
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
2021-12-16 08:59:06 -05:00
|
|
|
|
|
2021-02-25 19:43:43 +01:00
|
|
|
|
|
2021-02-15 21:27:50 +01:00
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
|
|
|
|
def music_list(request, id, status):
|
|
|
|
|
if request.method == 'GET':
|
2022-01-16 18:01:26 -05:00
|
|
|
|
if status.upper() not in MarkStatusEnum.names and status not in ['reviewed', 'tagged']:
|
2021-02-15 21:27:50 +01:00
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
if isinstance(id, str):
|
|
|
|
|
try:
|
|
|
|
|
username = id.split('@')[0]
|
|
|
|
|
site = id.split('@')[1]
|
|
|
|
|
except IndexError as e:
|
|
|
|
|
return HttpResponseBadRequest("Invalid user id")
|
|
|
|
|
query_kwargs = {'username': username, 'mastodon_site': site}
|
|
|
|
|
elif isinstance(id, int):
|
|
|
|
|
query_kwargs = {'pk': id}
|
|
|
|
|
try:
|
|
|
|
|
user = User.objects.get(**query_kwargs)
|
|
|
|
|
except ObjectDoesNotExist:
|
2022-02-13 17:00:55 -05:00
|
|
|
|
msg = _("😖哎呀,这位用户还没有加入本站,快去联邦宇宙呼唤TA来注册吧!")
|
2021-02-15 21:27:50 +01:00
|
|
|
|
sec_msg = _("目前只开放本站用户注册")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
'secondary_msg': sec_msg,
|
|
|
|
|
}
|
2021-12-16 08:59:06 -05:00
|
|
|
|
)
|
2022-01-16 18:01:26 -05:00
|
|
|
|
tag = request.GET.get('t', default='')
|
2021-02-15 21:27:50 +01:00
|
|
|
|
if not user == request.user:
|
|
|
|
|
# mastodon request
|
|
|
|
|
relation = get_relationship(request.user, user, request.session['oauth_token'])[0]
|
|
|
|
|
if relation['blocked_by']:
|
|
|
|
|
msg = _("你没有访问TA主页的权限😥")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
}
|
|
|
|
|
)
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
queryset = list(AlbumReview.get_available_by_user(user, relation['following']).order_by("-edited_time")) + \
|
|
|
|
|
list(SongReview.get_available_by_user(user, relation['following']).order_by("-edited_time"))
|
2022-01-16 18:01:26 -05:00
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
queryset = list(AlbumTag.find_by_user(tag, user, relation['following']).order_by("-mark__edited_time"))
|
2021-12-16 08:59:06 -05:00
|
|
|
|
else:
|
|
|
|
|
queryset = list(AlbumMark.get_available_by_user(user, relation['following']).filter(
|
|
|
|
|
status=MarkStatusEnum[status.upper()])) \
|
|
|
|
|
+ list(SongMark.get_available_by_user(user, relation['following']).filter(
|
|
|
|
|
status=MarkStatusEnum[status.upper()]))
|
|
|
|
|
|
2021-02-15 21:27:50 +01:00
|
|
|
|
user.target_site_id = get_cross_site_id(
|
|
|
|
|
user, request.user.mastodon_site, request.session['oauth_token'])
|
|
|
|
|
else:
|
2021-12-16 08:59:06 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
queryset = list(AlbumReview.objects.filter(owner=user).order_by("-edited_time")) + \
|
|
|
|
|
list(SongReview.objects.filter(owner=user).order_by("-edited_time"))
|
2022-01-16 18:01:26 -05:00
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
queryset = list(AlbumTag.objects.filter(content=tag, mark__owner=user).order_by("-mark__edited_time"))
|
2021-12-16 08:59:06 -05:00
|
|
|
|
else:
|
|
|
|
|
queryset = list(AlbumMark.objects.filter(owner=user, status=MarkStatusEnum[status.upper()])) \
|
|
|
|
|
+ list(SongMark.objects.filter(owner=user, status=MarkStatusEnum[status.upper()]))
|
2021-02-15 21:27:50 +01:00
|
|
|
|
queryset = sorted(queryset, key=lambda e: e.edited_time, reverse=True)
|
|
|
|
|
paginator = Paginator(queryset, ITEMS_PER_PAGE)
|
|
|
|
|
page_number = request.GET.get('page', default=1)
|
|
|
|
|
marks = paginator.get_page(page_number)
|
|
|
|
|
for mark in marks:
|
2022-01-16 18:01:26 -05:00
|
|
|
|
if mark.__class__ in [AlbumMark, AlbumReview, AlbumTag]:
|
2021-02-15 21:27:50 +01:00
|
|
|
|
mark.music = mark.album
|
|
|
|
|
mark.music.tag_list = mark.album.get_tags_manager().values('content').annotate(
|
|
|
|
|
tag_frequency=Count('content')).order_by('-tag_frequency')[:TAG_NUMBER_ON_LIST]
|
2021-12-16 08:59:06 -05:00
|
|
|
|
elif mark.__class__ == SongMark or mark.__class__ == SongReview:
|
2021-02-15 21:27:50 +01:00
|
|
|
|
mark.music = mark.song
|
|
|
|
|
mark.music.tag_list = mark.song.get_tags_manager().values('content').annotate(
|
|
|
|
|
tag_frequency=Count('content')).order_by('-tag_frequency')[:TAG_NUMBER_ON_LIST]
|
|
|
|
|
|
|
|
|
|
marks.pagination = PageLinksGenerator(PAGE_LINK_NUMBER, page_number, paginator.num_pages)
|
2022-01-16 18:01:26 -05:00
|
|
|
|
if status == 'reviewed':
|
|
|
|
|
list_title = str(_("评论过的音乐"))
|
|
|
|
|
elif status == 'tagged':
|
|
|
|
|
list_title = str(_(f"标记为「{tag}」的音乐"))
|
|
|
|
|
else:
|
|
|
|
|
list_title = str(MusicMarkStatusTranslator(MarkStatusEnum[status.upper()])) + str(_("的音乐"))
|
2021-02-15 21:27:50 +01:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'users/music_list.html',
|
|
|
|
|
{
|
|
|
|
|
'marks': marks,
|
|
|
|
|
'user': user,
|
2021-12-16 08:59:06 -05:00
|
|
|
|
'status': status,
|
|
|
|
|
'list_title': list_title,
|
2021-02-15 21:27:50 +01:00
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
2021-02-17 15:08:16 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
|
def set_layout(request):
|
|
|
|
|
if request.method == 'POST':
|
2021-12-15 21:54:24 -05:00
|
|
|
|
layout = json.loads(request.POST.get('layout'))
|
|
|
|
|
request.user.preference.home_layout = layout
|
2021-02-17 15:08:16 +01:00
|
|
|
|
request.user.preference.save()
|
|
|
|
|
return redirect(reverse("common:home"))
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
2021-02-15 21:27:50 +01:00
|
|
|
|
|
2020-05-05 23:50:48 +08:00
|
|
|
|
@login_required
|
|
|
|
|
def report(request):
|
|
|
|
|
if request.method == 'GET':
|
2020-05-07 18:00:39 +08:00
|
|
|
|
user_id = request.GET.get('user_id')
|
|
|
|
|
if user_id:
|
|
|
|
|
user = get_object_or_404(User, pk=user_id)
|
|
|
|
|
form = ReportForm(initial={'reported_user': user})
|
|
|
|
|
else:
|
|
|
|
|
form = ReportForm()
|
2020-05-05 23:50:48 +08:00
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'users/report.html',
|
|
|
|
|
{
|
|
|
|
|
'form': form,
|
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
elif request.method == 'POST':
|
|
|
|
|
form = ReportForm(request.POST)
|
|
|
|
|
if form.is_valid():
|
|
|
|
|
form.instance.is_read = False
|
|
|
|
|
form.instance.submit_user = request.user
|
|
|
|
|
form.save()
|
|
|
|
|
return redirect(reverse("users:home", args=[form.instance.reported_user.id]))
|
|
|
|
|
else:
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'users/report.html',
|
|
|
|
|
{
|
|
|
|
|
'form': form,
|
2021-12-16 08:59:06 -05:00
|
|
|
|
}
|
2020-05-05 23:50:48 +08:00
|
|
|
|
)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
|
def manage_report(request):
|
|
|
|
|
if request.method == 'GET':
|
|
|
|
|
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',
|
|
|
|
|
{
|
|
|
|
|
'reports': reports,
|
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
else:
|
|
|
|
|
return HttpResponseBadRequest()
|
|
|
|
|
|
|
|
|
|
|
2021-12-26 15:55:16 -05:00
|
|
|
|
@login_required
|
|
|
|
|
def collection_list(request, id):
|
|
|
|
|
from collection.views import list
|
|
|
|
|
if isinstance(id, str):
|
|
|
|
|
try:
|
|
|
|
|
username = id.split('@')[0]
|
|
|
|
|
site = id.split('@')[1]
|
|
|
|
|
except IndexError as e:
|
|
|
|
|
return HttpResponseBadRequest("Invalid user id")
|
|
|
|
|
query_kwargs = {'username': username, 'mastodon_site': site}
|
|
|
|
|
elif isinstance(id, int):
|
|
|
|
|
query_kwargs = {'pk': id}
|
|
|
|
|
try:
|
|
|
|
|
user = User.objects.get(**query_kwargs)
|
|
|
|
|
except ObjectDoesNotExist:
|
2022-02-13 17:00:55 -05:00
|
|
|
|
msg = _("😖哎呀,这位用户还没有加入本站,快去联邦宇宙呼唤TA来注册吧!")
|
2021-12-26 15:55:16 -05:00
|
|
|
|
sec_msg = _("目前只开放本站用户注册")
|
|
|
|
|
return render(
|
|
|
|
|
request,
|
|
|
|
|
'common/error.html',
|
|
|
|
|
{
|
|
|
|
|
'msg': msg,
|
|
|
|
|
'secondary_msg': sec_msg,
|
|
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
return list(request, user.id)
|
|
|
|
|
|
|
|
|
|
|
2020-05-01 22:46:15 +08:00
|
|
|
|
# Utils
|
|
|
|
|
########################################
|
2021-12-15 12:54:24 -05:00
|
|
|
|
def refresh_mastodon_data_task(user, token=None):
|
|
|
|
|
if token:
|
|
|
|
|
user.mastodon_token = token
|
2021-12-14 16:06:27 -05:00
|
|
|
|
if user.refresh_mastodon_data():
|
|
|
|
|
user.save()
|
|
|
|
|
print(f"{user} mastodon data refreshed")
|
|
|
|
|
else:
|
|
|
|
|
print(f"{user} mastodon data refresh failed")
|
|
|
|
|
|
|
|
|
|
|
2020-05-01 22:46:15 +08:00
|
|
|
|
def auth_login(request, user, token):
|
|
|
|
|
""" Decorates django ``login()``. Attach token to session."""
|
|
|
|
|
request.session['oauth_token'] = token
|
|
|
|
|
auth.login(request, user)
|
2021-12-20 23:51:35 -05:00
|
|
|
|
if user.mastodon_last_refresh < timezone.now() - timedelta(hours=1) or user.mastodon_account == {}:
|
2021-12-15 21:54:24 -05:00
|
|
|
|
# refresh_mastodon_data_task(user, token)
|
|
|
|
|
django_rq.get_queue('mastodon').enqueue(refresh_mastodon_data_task, user, token)
|
2020-05-01 22:46:15 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def auth_logout(request):
|
|
|
|
|
""" Decorates django ``logout()``. Release token in session."""
|
|
|
|
|
del request.session['oauth_token']
|
2021-12-16 08:59:06 -05:00
|
|
|
|
auth.logout(request)
|
2021-12-11 09:43:31 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
|
|
|
|
def preferences(request):
|
|
|
|
|
if request.method == 'POST':
|
|
|
|
|
request.user.preference.mastodon_publish_public = bool(request.POST.get('mastodon_publish_public'))
|
|
|
|
|
request.user.preference.save()
|
|
|
|
|
return render(request, 'users/preferences.html', {'mastodon_publish_public': request.user.preference.mastodon_publish_public})
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
|
|
|
|
def data(request):
|
|
|
|
|
return render(request, 'users/data.html', {
|
|
|
|
|
'latest_task': request.user.user_synctasks.order_by("-id").first(),
|
|
|
|
|
'export_status': request.user.preference.export_status
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
|
|
|
|
def export_reviews(request):
|
|
|
|
|
if request.method != 'POST':
|
|
|
|
|
return redirect(reverse("users:data"))
|
|
|
|
|
return render(request, 'users/data.html')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@mastodon_request_included
|
|
|
|
|
@login_required
|
|
|
|
|
def export_marks(request):
|
|
|
|
|
if request.method == 'POST':
|
|
|
|
|
if not request.user.preference.export_status.get('marks_pending'):
|
2021-12-12 18:15:42 -05:00
|
|
|
|
django_rq.get_queue('export').enqueue(export_marks_task, request.user)
|
2021-12-11 09:43:31 -05:00
|
|
|
|
request.user.preference.export_status['marks_pending'] = True
|
|
|
|
|
request.user.preference.save()
|
2021-12-21 21:25:41 -05:00
|
|
|
|
messages.add_message(request, messages.INFO, _('导出已开始。'))
|
2021-12-11 09:43:31 -05:00
|
|
|
|
return redirect(reverse("users:data"))
|
|
|
|
|
else:
|
|
|
|
|
with open(request.user.preference.export_status['marks_file'], 'rb') as fh:
|
|
|
|
|
response = HttpResponse(fh.read(), content_type="application/vnd.ms-excel")
|
|
|
|
|
response['Content-Disposition'] = 'attachment;filename="marks.xlsx"'
|
|
|
|
|
return response
|
2021-12-15 12:54:24 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
|
def sync_mastodon(request):
|
|
|
|
|
if request.method == 'POST':
|
2021-12-17 21:27:56 +00:00
|
|
|
|
django_rq.get_queue('mastodon').enqueue(refresh_mastodon_data_task, request.user, request.session['oauth_token'])
|
2021-12-21 21:25:41 -05:00
|
|
|
|
messages.add_message(request, messages.INFO, _('同步已开始。'))
|
|
|
|
|
return redirect(reverse("users:data"))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
|
def reset_visibility(request):
|
|
|
|
|
if request.method == 'POST':
|
|
|
|
|
visibility = int(request.POST.get('visibility'))
|
|
|
|
|
visibility = visibility if visibility >= 0 and visibility <= 2 else 0
|
|
|
|
|
BookMark.objects.filter(owner=request.user).update(visibility=visibility)
|
|
|
|
|
MovieMark.objects.filter(owner=request.user).update(visibility=visibility)
|
|
|
|
|
GameMark.objects.filter(owner=request.user).update(visibility=visibility)
|
|
|
|
|
AlbumMark.objects.filter(owner=request.user).update(visibility=visibility)
|
|
|
|
|
SongMark.objects.filter(owner=request.user).update(visibility=visibility)
|
|
|
|
|
messages.add_message(request, messages.INFO, _('已重置。'))
|
2021-12-15 12:54:24 -05:00
|
|
|
|
return redirect(reverse("users:data"))
|
2021-12-21 23:34:36 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
|
def clear_data(request):
|
|
|
|
|
if request.method == 'POST':
|
|
|
|
|
if request.POST.get('verification') == request.user.mastodon_username:
|
|
|
|
|
BookMark.objects.filter(owner=request.user).delete()
|
|
|
|
|
MovieMark.objects.filter(owner=request.user).delete()
|
|
|
|
|
GameMark.objects.filter(owner=request.user).delete()
|
|
|
|
|
AlbumMark.objects.filter(owner=request.user).delete()
|
|
|
|
|
SongMark.objects.filter(owner=request.user).delete()
|
|
|
|
|
BookReview.objects.filter(owner=request.user).delete()
|
|
|
|
|
MovieReview.objects.filter(owner=request.user).delete()
|
|
|
|
|
GameReview.objects.filter(owner=request.user).delete()
|
|
|
|
|
AlbumReview.objects.filter(owner=request.user).delete()
|
|
|
|
|
SongReview.objects.filter(owner=request.user).delete()
|
|
|
|
|
request.user.first_name = request.user.username
|
|
|
|
|
request.user.last_name = request.user.mastodon_site
|
|
|
|
|
request.user.is_active = False
|
|
|
|
|
request.user.username = 'removed_' + str(request.user.id)
|
|
|
|
|
request.user.mastodon_id = 0
|
|
|
|
|
request.user.mastodon_site = 'removed'
|
|
|
|
|
request.user.mastodon_token = ''
|
|
|
|
|
request.user.mastodon_locked = False
|
|
|
|
|
request.user.mastodon_followers = []
|
|
|
|
|
request.user.mastodon_following = []
|
|
|
|
|
request.user.mastodon_mutes = []
|
|
|
|
|
request.user.mastodon_blocks = []
|
|
|
|
|
request.user.mastodon_domain_blocks = []
|
|
|
|
|
request.user.mastodon_account = {}
|
|
|
|
|
request.user.save()
|
|
|
|
|
auth_logout(request)
|
|
|
|
|
return redirect(reverse("users:login"))
|
|
|
|
|
else:
|
|
|
|
|
messages.add_message(request, messages.ERROR, _('验证信息不符。'))
|
|
|
|
|
return redirect(reverse("users:data"))
|