lib.itmens/users/data.py

242 lines
8.6 KiB
Python
Raw Normal View History

2024-05-15 03:18:27 -04:00
import datetime
2024-01-10 22:20:57 -05:00
import os
import django_rq
from django.conf import settings
from django.contrib import messages
from django.contrib.auth.decorators import login_required
2024-05-15 03:18:27 -04:00
from django.db.models import Min
from django.http import HttpResponse
from django.shortcuts import redirect, render
from django.urls import reverse
from django.utils.translation import gettext_lazy as _
2022-12-31 00:20:20 -05:00
from common.config import *
2024-05-20 23:17:47 -04:00
from common.utils import GenerateDateUUIDMediaFilePath, profile_identity_required
from journal.exporters.doufen import export_marks_task
from journal.importers.douban import DoubanImporter
from journal.importers.goodreads import GoodreadsImporter
2024-01-10 22:20:57 -05:00
from journal.importers.letterboxd import LetterboxdImporter
from journal.importers.opml import OPMLImporter
2024-05-15 03:18:27 -04:00
from journal.models import ShelfType, reset_journal_visibility_for_user
from mastodon.api import *
from social.models import reset_social_visibility_for_user
from .account import *
from .tasks import *
@login_required
2024-05-23 17:46:00 -04:00
def preferences(request):
if not request.user.registration_complete:
return redirect(reverse("users:register"))
preference = request.user.preference
2023-12-29 02:11:36 -05:00
identity = request.user.identity
2022-12-31 00:20:20 -05:00
if request.method == "POST":
2023-12-29 02:11:36 -05:00
identity.anonymous_viewable = bool(request.POST.get("anonymous_viewable"))
identity.save(update_fields=["anonymous_viewable"])
2022-12-31 00:20:20 -05:00
preference.default_visibility = int(request.POST.get("default_visibility"))
preference.mastodon_default_repost = (
int(request.POST.get("mastodon_default_repost", 0)) == 1
)
2023-04-20 10:12:05 -04:00
preference.classic_homepage = int(request.POST.get("classic_homepage"))
2023-07-12 01:11:15 -04:00
preference.hidden_categories = request.POST.getlist("hidden_categories")
preference.post_public_mode = int(request.POST.get("post_public_mode"))
2022-12-31 00:20:20 -05:00
preference.show_last_edit = bool(request.POST.get("show_last_edit"))
2023-12-15 19:31:07 -05:00
preference.mastodon_repost_mode = int(
request.POST.get("mastodon_repost_mode", 0)
)
2022-12-31 00:20:20 -05:00
preference.mastodon_append_tag = request.POST.get(
"mastodon_append_tag", ""
).strip()
preference.save(
update_fields=[
"default_visibility",
"post_public_mode",
2022-12-31 00:20:20 -05:00
"classic_homepage",
"mastodon_append_tag",
"mastodon_repost_mode",
"mastodon_default_repost",
2022-12-31 00:20:20 -05:00
"show_last_edit",
2023-07-12 01:11:15 -04:00
"hidden_categories",
2022-12-31 00:20:20 -05:00
]
)
2024-04-03 23:10:21 -04:00
lang = request.POST.get("language")
if lang in dict(settings.LANGUAGES).keys() and lang != request.user.language:
request.user.language = lang
request.user.save(update_fields=["language"])
2023-07-12 01:11:15 -04:00
clear_preference_cache(request)
return render(
request,
"users/preferences.html",
{"enable_local_only": settings.ENABLE_LOCAL_ONLY},
)
@login_required
2024-05-23 17:46:00 -04:00
def data(request):
if not request.user.registration_complete:
return redirect(reverse("users:register"))
2024-05-15 03:18:27 -04:00
current_year = datetime.date.today().year
queryset = request.user.identity.shelf_manager.get_shelf(
ShelfType.COMPLETE
).members.all()
start_date = queryset.aggregate(Min("created_time"))["created_time__min"]
start_year = start_date.year if start_date else current_year
years = reversed(range(start_year, current_year + 1))
2022-12-31 00:20:20 -05:00
return render(
request,
"users/data.html",
{
"allow_any_site": settings.MASTODON_ALLOW_ANY_SITE,
"import_status": request.user.preference.import_status,
"export_status": request.user.preference.export_status,
2024-01-10 22:20:57 -05:00
"letterboxd_task": LetterboxdImporter.latest_task(request.user),
2024-05-15 03:18:27 -04:00
"years": years,
2022-12-31 00:20:20 -05:00
},
)
@login_required
def data_import_status(request):
return render(
request,
"users/data_import_status.html",
{
"import_status": request.user.preference.import_status,
2022-12-31 00:20:20 -05:00
},
)
@login_required
def export_reviews(request):
2022-12-31 00:20:20 -05:00
if request.method != "POST":
return redirect(reverse("users:data"))
2022-12-31 00:20:20 -05:00
return render(request, "users/data.html")
@login_required
def export_marks(request):
2022-12-31 00:20:20 -05:00
if request.method == "POST":
2023-11-28 17:13:47 -05:00
django_rq.get_queue("export").enqueue(export_marks_task, request.user)
request.user.preference.export_status["marks_pending"] = True
request.user.preference.save()
2024-05-15 20:41:03 -04:00
messages.add_message(request, messages.INFO, _("Generating exports."))
return redirect(reverse("users:data"))
else:
try:
2022-12-31 00:20:20 -05:00
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
except Exception:
2024-05-15 20:41:03 -04:00
messages.add_message(
request, messages.ERROR, _("Export file expired. Please export again.")
)
return redirect(reverse("users:data"))
@login_required
def sync_mastodon(request):
if request.method == "POST" and request.user.mastodon_username:
2022-12-31 00:20:20 -05:00
django_rq.get_queue("mastodon").enqueue(
refresh_mastodon_data_task, request.user.pk
2022-12-31 00:20:20 -05:00
)
2024-05-15 20:41:03 -04:00
messages.add_message(request, messages.INFO, _("Sync in progress."))
2023-07-07 16:54:15 -04:00
return redirect(reverse("users:info"))
@login_required
def sync_mastodon_preference(request):
if request.method == "POST":
request.user.preference.mastodon_skip_userinfo = (
request.POST.get("mastodon_sync_userinfo", "") == ""
)
request.user.preference.mastodon_skip_relationship = (
request.POST.get("mastodon_sync_relationship", "") == ""
)
request.user.preference.save()
2024-05-15 20:41:03 -04:00
messages.add_message(request, messages.INFO, _("Settings saved."))
return redirect(reverse("users:info"))
@login_required
def reset_visibility(request):
2022-12-31 00:20:20 -05:00
if request.method == "POST":
visibility = int(request.POST.get("visibility"))
visibility = visibility if visibility >= 0 and visibility <= 2 else 0
2023-12-09 16:25:41 -05:00
reset_journal_visibility_for_user(request.user.identity, visibility)
reset_social_visibility_for_user(request.user.identity, visibility)
2024-05-15 20:41:03 -04:00
messages.add_message(request, messages.INFO, _("Reset completed."))
return redirect(reverse("users:data"))
@login_required
def import_goodreads(request):
2022-12-31 00:20:20 -05:00
if request.method == "POST":
raw_url = request.POST.get("url")
if GoodreadsImporter.import_from_url(raw_url, request.user):
2024-05-15 20:41:03 -04:00
messages.add_message(request, messages.INFO, _("Import in progress."))
else:
2024-05-15 20:41:03 -04:00
messages.add_message(request, messages.ERROR, _("Invalid URL."))
return redirect(reverse("users:data"))
@login_required
def import_douban(request):
2022-12-31 00:20:20 -05:00
if request.method == "POST":
2023-01-09 20:36:12 -05:00
importer = DoubanImporter(
request.user,
2023-07-12 16:33:15 -04:00
int(request.POST.get("visibility", 0)),
int(request.POST.get("import_mode", 0)),
2023-01-09 20:36:12 -05:00
)
2022-12-31 00:20:20 -05:00
if importer.import_from_file(request.FILES["file"]):
2024-05-15 20:41:03 -04:00
messages.add_message(
request, messages.INFO, _("File is uploaded and will be imported soon.")
)
else:
2024-05-15 20:41:03 -04:00
messages.add_message(request, messages.ERROR, _("Invalid file."))
return redirect(reverse("users:data"))
2023-01-29 20:05:30 -05:00
2024-01-10 22:20:57 -05:00
@login_required
def import_letterboxd(request):
if request.method == "POST":
f = (
settings.MEDIA_ROOT
+ "/"
+ GenerateDateUUIDMediaFilePath("x.zip", settings.SYNC_FILE_PATH_ROOT)
)
os.makedirs(os.path.dirname(f), exist_ok=True)
with open(f, "wb+") as destination:
for chunk in request.FILES["file"].chunks():
destination.write(chunk)
LetterboxdImporter.enqueue(
request.user,
visibility=int(request.POST.get("visibility", 0)),
file=f,
)
2024-05-15 20:41:03 -04:00
messages.add_message(
request, messages.INFO, _("File is uploaded and will be imported soon.")
)
2024-01-10 22:20:57 -05:00
return redirect(reverse("users:data"))
2023-01-29 20:05:30 -05:00
@login_required
def import_opml(request):
if request.method == "POST":
importer = OPMLImporter(
request.user,
int(request.POST.get("visibility", 0)),
int(request.POST.get("import_mode", 0)),
)
if importer.import_from_file(request.FILES["file"]):
2024-05-15 20:41:03 -04:00
messages.add_message(
request, messages.INFO, _("File is uploaded and will be imported soon.")
)
2023-01-29 20:05:30 -05:00
else:
2024-05-15 20:41:03 -04:00
messages.add_message(request, messages.ERROR, _("Invalid file."))
2023-01-29 20:05:30 -05:00
return redirect(reverse("users:data"))