lib.itmens/users/views.py

795 lines
29 KiB
Python
Raw Normal View History

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 *
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
2020-05-01 22:46:15 +08:00
# Views
########################################
# 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:
token = obtain_token(site, request, code)
except ObjectDoesNotExist:
return HttpResponseBadRequest("Mastodon site not registered")
2020-05-01 22:46:15 +08:00
if token:
# oauth is completed when token aquired
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)
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'))
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
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
# 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,
'selected_site': selected_site,
2020-05-01 22:46:15 +08:00
}
)
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':
2020-10-22 21:45:05 +02: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']
2020-10-22 21:45:05 +02:00
user_data = get_user_data(request.COOKIES['mastodon_domain'], token)
2021-02-12 19:23:23 +01:00
if user_data is None:
return render(
request,
'common/error.html',
{
'msg': _("长毛象访问失败😫")
}
)
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'],
2020-05-01 22:46:15 +08:00
)
new_user.save()
del request.session['new_user_token']
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
2020-05-05 23:50:48 +08:00
@mastodon_request_included
@login_required
def home(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):
2020-05-05 23:50:48 +08:00
query_kwargs = {'pk': id}
try:
user = User.objects.get(**query_kwargs)
except ObjectDoesNotExist:
msg = _("😖哎呀这位老师还没有注册书影音呢快去长毛象喊TA来吧")
sec_msg = _("目前只开放本站用户注册")
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()
# visit other's home page
2020-05-05 23:50:48 +08:00
else:
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'])
# 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,
}
)
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'])
2020-05-05 23:50:48 +08:00
2021-04-25 11:18:36 +02:00
2021-02-25 19:43:43 +01:00
# book marks
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")
2020-10-22 21:45:05 +02: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"
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-02-25 19:43:43 +01:00
'layout': layout,
'reports': reports,
'unread_announcements': unread_announcements,
}
)
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):
"""
Filter marks by amount limits and order them edited time, store results in a dict,
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:
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-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
2020-07-03 15:36:23 +08: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:
msg = _("😖哎呀这位老师还没有注册书影音呢快去长毛象喊TA来吧")
sec_msg = _("目前只开放本站用户注册")
return render(
request,
'common/error.html',
{
'msg': msg,
'secondary_msg': sec_msg,
}
)
# 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:
msg = _("😖哎呀这位老师还没有注册书影音呢快去长毛象喊TA来吧")
sec_msg = _("目前只开放本站用户注册")
return render(
request,
'common/error.html',
{
'msg': msg,
'secondary_msg': sec_msg,
}
)
# 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':
if not status.upper() in MarkStatusEnum.names:
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-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:
msg = _("😖哎呀这位老师还没有注册书影音呢快去长毛象喊TA来吧")
sec_msg = _("目前只开放本站用户注册")
return render(
request,
'common/error.html',
{
'msg': msg,
'secondary_msg': sec_msg,
}
)
if not user == request.user:
# 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,
}
)
queryset = BookMark.get_available_by_user(user, relation['following']).filter(
2020-07-23 13:36:00 +08:00
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:
2020-07-23 13:36:00 +08:00
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)
2021-02-25 19:43:43 +01:00
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,
'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':
if not status.upper() in MarkStatusEnum.names:
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:
msg = _("😖哎呀这位老师还没有注册书影音呢快去长毛象喊TA来吧")
sec_msg = _("目前只开放本站用户注册")
return render(
request,
'common/error.html',
{
'msg': msg,
'secondary_msg': sec_msg,
}
2021-02-25 19:43:43 +01:00
)
2020-10-03 23:27:41 +02:00
if not user == request.user:
# 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-02-25 19:43:43 +01:00
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:
queryset = MovieMark.objects.filter(
owner=user, status=MarkStatusEnum[status.upper()]).order_by("-edited_time")
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)
2021-02-25 19:43:43 +01:00
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,
'list_title' : list_title,
}
)
else:
return HttpResponseBadRequest()
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':
if not status.upper() in MarkStatusEnum.names:
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:
msg = _("😖哎呀这位老师还没有注册书影音呢快去长毛象喊TA来吧")
sec_msg = _("目前只开放本站用户注册")
return render(
request,
'common/error.html',
{
'msg': msg,
'secondary_msg': sec_msg,
}
)
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,
}
)
user.target_site_id = get_cross_site_id(
user, request.user.mastodon_site, request.session['oauth_token'])
queryset = GameMark.get_available_by_user(user, relation['following']).filter(
status=MarkStatusEnum[status.upper()]).order_by("-edited_time")
else:
queryset = GameMark.objects.filter(
owner=user, status=MarkStatusEnum[status.upper()]).order_by("-edited_time")
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)
list_title = str(GameMarkStatusTranslator(MarkStatusEnum[status.upper()])) + str(_("的游戏"))
return render(
request,
'users/game_list.html',
{
'marks': marks,
'user': user,
'list_title' : list_title,
}
)
else:
return HttpResponseBadRequest()
2021-02-15 21:27:50 +01:00
@mastodon_request_included
@login_required
def music_list(request, id, status):
if request.method == 'GET':
if not status.upper() in MarkStatusEnum.names:
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:
msg = _("😖哎呀这位老师还没有注册书影音呢快去长毛象喊TA来吧")
sec_msg = _("目前只开放本站用户注册")
return render(
request,
'common/error.html',
{
'msg': msg,
'secondary_msg': sec_msg,
}
)
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,
}
)
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()]))
user.target_site_id = get_cross_site_id(
user, request.user.mastodon_site, request.session['oauth_token'])
else:
queryset = list(AlbumMark.objects.filter(owner=user, status=MarkStatusEnum[status.upper()])) \
+ list(SongMark.objects.filter(owner=user, status=MarkStatusEnum[status.upper()]))
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:
if mark.__class__ == AlbumMark:
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]
elif mark.__class__ == SongMark:
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)
2021-02-25 19:43:43 +01:00
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,
'list_title' : list_title,
}
)
else:
return HttpResponseBadRequest()
2021-02-17 15:08:16 +01:00
@login_required
def set_layout(request):
if request.method == 'POST':
# json to python
raw_layout_data = request.POST.get('layout').replace('false', 'False').replace('true', 'True')
layout = eval(raw_layout_data)
request.user.preference.home_layout = eval(raw_layout_data)
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,
}
)
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()
2020-05-01 22:46:15 +08:00
# Utils
########################################
def auth_login(request, user, token):
""" Decorates django ``login()``. Attach token to session."""
request.session['oauth_token'] = token
auth.login(request, user)
def auth_logout(request):
""" Decorates django ``logout()``. Release token in session."""
del request.session['oauth_token']
2020-07-10 21:28:09 +08:00
auth.logout(request)