Reformat using black

chat_box/views.py

@@ -1,11 +1,27 @@
 from django.utils.translation import gettext as _
 from django.views.generic import ListView
-from django.http import HttpResponse, JsonResponse, HttpResponseBadRequest, HttpResponsePermanentRedirect, HttpResponseRedirect
+from django.http import (
+    HttpResponse,
+    JsonResponse,
+    HttpResponseBadRequest,
+    HttpResponsePermanentRedirect,
+    HttpResponseRedirect,
+)
 from django.core.paginator import Paginator
 from django.core.exceptions import PermissionDenied
 from django.shortcuts import render
 from django.forms.models import model_to_dict
-from django.db.models import Case, BooleanField, When, Q, Subquery, OuterRef, Exists, Count, IntegerField
+from django.db.models import (
+    Case,
+    BooleanField,
+    When,
+    Q,
+    Subquery,
+    OuterRef,
+    Exists,
+    Count,
+    IntegerField,
+)
 from django.db.models.functions import Coalesce
 from django.utils import timezone
 from django.contrib.auth.decorators import login_required
@@ -24,10 +40,10 @@ import json
 
 
 class ChatView(ListView):
-    context_object_name = 'message'
-    template_name = 'chat/chat.html'
-    title = _('Chat Box')
-    
+    context_object_name = "message"
+    template_name = "chat/chat.html"
+    title = _("Chat Box")
+
     def __init__(self):
         super().__init__()
         self.room_id = None
@@ -40,8 +56,8 @@ class ChatView(ListView):
         return self.messages
 
     def get(self, request, *args, **kwargs):
-        request_room = kwargs['room_id']
-        page = request.GET.get('page')
+        request_room = kwargs["room_id"]
+        page = request.GET.get("page")
 
         if request_room:
             try:
@@ -64,109 +80,121 @@ class ChatView(ListView):
 
         cur_page = self.paginator.get_page(page)
 
-        return render(request, 'chat/message_list.html', {
-            'object_list': cur_page.object_list,
-            'num_pages': self.paginator.num_pages
-        })
+        return render(
+            request,
+            "chat/message_list.html",
+            {
+                "object_list": cur_page.object_list,
+                "num_pages": self.paginator.num_pages,
+            },
+        )
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
 
-        context['title'] = self.title
-        context['last_msg'] = event.last()
-        context['status_sections'] = get_status_context(self.request)
-        context['room'] = self.room_id
-        context['unread_count_lobby'] = get_unread_count(None, self.request.profile)
+        context["title"] = self.title
+        context["last_msg"] = event.last()
+        context["status_sections"] = get_status_context(self.request)
+        context["room"] = self.room_id
+        context["unread_count_lobby"] = get_unread_count(None, self.request.profile)
         if self.room:
             users_room = [self.room.user_one, self.room.user_two]
             users_room.remove(self.request.profile)
-            context['other_user'] =  users_room[0]
-            context['other_online'] = get_user_online_status(context['other_user'])
-            context['is_ignored'] = Ignore.is_ignored(self.request.profile, context['other_user'])
+            context["other_user"] = users_room[0]
+            context["other_online"] = get_user_online_status(context["other_user"])
+            context["is_ignored"] = Ignore.is_ignored(
+                self.request.profile, context["other_user"]
+            )
         else:
-            context['online_count'] = get_online_count()
-        context['message_template'] = {
-            'author': self.request.profile,
-            'id': '$id',
-            'time': timezone.now(),
-            'body': '$body'
-        }        
+            context["online_count"] = get_online_count()
+        context["message_template"] = {
+            "author": self.request.profile,
+            "id": "$id",
+            "time": timezone.now(),
+            "body": "$body",
+        }
         return context
 
 
 def delete_message(request):
-    ret = {'delete': 'done'}
-    
-    if request.method == 'GET':
+    ret = {"delete": "done"}
+
+    if request.method == "GET":
         return JsonResponse(ret)
 
     if request.user.is_staff:
         try:
-            messid = int(request.POST.get('message'))
+            messid = int(request.POST.get("message"))
             mess = Message.objects.get(id=messid)
         except:
             return HttpResponseBadRequest()
-        
+
         mess.hidden = True
         mess.save()
-        
+
         return JsonResponse(ret)
-    
+
     return JsonResponse(ret)
 
 
 @login_required
 def post_message(request):
-    ret = {'msg': 'posted'}
-    if request.method != 'POST':
+    ret = {"msg": "posted"}
+    if request.method != "POST":
         return HttpResponseBadRequest()
-    if len(request.POST['body']) > 5000:
+    if len(request.POST["body"]) > 5000:
         return HttpResponseBadRequest()
 
     room = None
-    if request.POST['room']:
-        room = Room.objects.get(id=request.POST['room'])
-    
+    if request.POST["room"]:
+        room = Room.objects.get(id=request.POST["room"])
+
     if not can_access_room(request, room) or request.profile.mute:
         return HttpResponseBadRequest()
 
-    new_message = Message(author=request.profile,
-                          body=request.POST['body'],
-                          room=room)
+    new_message = Message(author=request.profile, body=request.POST["body"], room=room)
     new_message.save()
 
     if not room:
-        event.post('chat_lobby', {
-            'type': 'lobby',
-            'author_id': request.profile.id, 
-            'message': new_message.id,
-            'room': 'None',
-            'tmp_id': request.POST.get('tmp_id')
-        })
+        event.post(
+            "chat_lobby",
+            {
+                "type": "lobby",
+                "author_id": request.profile.id,
+                "message": new_message.id,
+                "room": "None",
+                "tmp_id": request.POST.get("tmp_id"),
+            },
+        )
     else:
         for user in room.users():
-            event.post('chat_' + str(user.id), {
-                'type': 'private',
-                'author_id': request.profile.id, 
-                'message': new_message.id,
-                'room': room.id,
-                'tmp_id': request.POST.get('tmp_id')
-            })   
-    
+            event.post(
+                "chat_" + str(user.id),
+                {
+                    "type": "private",
+                    "author_id": request.profile.id,
+                    "message": new_message.id,
+                    "room": room.id,
+                    "tmp_id": request.POST.get("tmp_id"),
+                },
+            )
+
     return JsonResponse(ret)
 
 
 def can_access_room(request, room):
-    return not room or room.user_one == request.profile or room.user_two == request.profile
+    return (
+        not room or room.user_one == request.profile or room.user_two == request.profile
+    )
 
 
 @login_required
 def chat_message_ajax(request):
-    if request.method != 'GET':
+    if request.method != "GET":
         return HttpResponseBadRequest()
 
     try:
-        message_id = request.GET['message']
+        message_id = request.GET["message"]
     except KeyError:
         return HttpResponseBadRequest()
 
@@ -174,22 +202,26 @@ def chat_message_ajax(request):
         message = Message.objects.filter(hidden=False).get(id=message_id)
         room = message.room
         if room and not room.contain(request.profile):
-            return HttpResponse('Unauthorized', status=401)
+            return HttpResponse("Unauthorized", status=401)
     except Message.DoesNotExist:
         return HttpResponseBadRequest()
-    return render(request, 'chat/message.html', {
-        'message': message,
-    })
+    return render(
+        request,
+        "chat/message.html",
+        {
+            "message": message,
+        },
+    )
 
 
 @login_required
 def update_last_seen(request, **kwargs):
-    if 'room_id' in kwargs:
-        room_id = kwargs['room_id']
-    elif request.method == 'GET':
-        room_id = request.GET.get('room')
-    elif request.method == 'POST':
-        room_id = request.POST.get('room')
+    if "room_id" in kwargs:
+        room_id = kwargs["room_id"]
+    elif request.method == "GET":
+        room_id = request.GET.get("room")
+    elif request.method == "POST":
+        room_id = request.POST.get("room")
     else:
         return HttpResponseBadRequest()
 
@@ -210,11 +242,11 @@ def update_last_seen(request, **kwargs):
     user_room.last_seen = timezone.now()
     user_room.save()
 
-    return JsonResponse({'msg': 'updated'})
+    return JsonResponse({"msg": "updated"})
 
 
 def get_online_count():
-    last_two_minutes = timezone.now()-timezone.timedelta(minutes=2)
+    last_two_minutes = timezone.now() - timezone.timedelta(minutes=2)
     return Profile.objects.filter(last_access__gte=last_two_minutes).count()
 
 
@@ -225,10 +257,10 @@ def get_user_online_status(user):
 
 
 def user_online_status_ajax(request):
-    if request.method != 'GET':
+    if request.method != "GET":
         return HttpResponseBadRequest()
 
-    user_id = request.GET.get('user')
+    user_id = request.GET.get("user")
 
     if user_id:
         try:
@@ -238,37 +270,45 @@ def user_online_status_ajax(request):
             return HttpResponseBadRequest()
 
         is_online = get_user_online_status(user)
-        return render(request, 'chat/user_online_status.html', {
-                'other_user': user,
-                'other_online': is_online,
-                'is_ignored': Ignore.is_ignored(request.profile, user)
-            })
+        return render(
+            request,
+            "chat/user_online_status.html",
+            {
+                "other_user": user,
+                "other_online": is_online,
+                "is_ignored": Ignore.is_ignored(request.profile, user),
+            },
+        )
     else:
-        return render(request, 'chat/user_online_status.html', {
-                'online_count': get_online_count(),
-            })
+        return render(
+            request,
+            "chat/user_online_status.html",
+            {
+                "online_count": get_online_count(),
+            },
+        )
 
 
 def get_online_status(request_user, queryset, rooms=None):
     if not queryset:
         return None
-    last_two_minutes = timezone.now()-timezone.timedelta(minutes=2)
+    last_two_minutes = timezone.now() - timezone.timedelta(minutes=2)
     ret = []
 
     if rooms:
         unread_count = get_unread_count(rooms, request_user)
         count = {}
         for i in unread_count:
-            count[i['other_user']] = i['unread_count']
+            count[i["other_user"]] = i["unread_count"]
 
     for user in queryset:
         is_online = False
-        if (user.last_access >= last_two_minutes):
+        if user.last_access >= last_two_minutes:
             is_online = True
-        user_dict = {'user': user, 'is_online': is_online}
+        user_dict = {"user": user, "is_online": is_online}
         if rooms and user.id in count:
-            user_dict['unread_count'] = count[user.id]
-        user_dict['url'] = encrypt_url(request_user.id, user.id)
+            user_dict["unread_count"] = count[user.id]
+        user_dict["url"] = encrypt_url(request_user.id, user.id)
         ret.append(user_dict)
     return ret
 
@@ -281,66 +321,82 @@ def get_status_context(request, include_ignored=False):
         ignored_users = Ignore.get_ignored_users(request.profile)
         queryset = Profile.objects.exclude(id__in=ignored_users)
 
-    last_two_minutes = timezone.now()-timezone.timedelta(minutes=2)
-    recent_profile = Room.objects.filter(
-            Q(user_one=request.profile) | Q(user_two=request.profile)
-        ).annotate(
+    last_two_minutes = timezone.now() - timezone.timedelta(minutes=2)
+    recent_profile = (
+        Room.objects.filter(Q(user_one=request.profile) | Q(user_two=request.profile))
+        .annotate(
             last_msg_time=Subquery(
-                Message.objects.filter(room=OuterRef('pk')).values('time')[:1]
+                Message.objects.filter(room=OuterRef("pk")).values("time")[:1]
             ),
             other_user=Case(
-                When(user_one=request.profile, then='user_two'),
-                default='user_one',
-            )
-        ).filter(last_msg_time__isnull=False)\
-        .exclude(other_user__in=ignored_users)\
-        .order_by('-last_msg_time').values('other_user', 'id')[:20]
+                When(user_one=request.profile, then="user_two"),
+                default="user_one",
+            ),
+        )
+        .filter(last_msg_time__isnull=False)
+        .exclude(other_user__in=ignored_users)
+        .order_by("-last_msg_time")
+        .values("other_user", "id")[:20]
+    )
 
-    recent_profile_id = [str(i['other_user']) for i in recent_profile]
-    joined_id = ','.join(recent_profile_id)
-    recent_rooms = [int(i['id']) for i in recent_profile]
+    recent_profile_id = [str(i["other_user"]) for i in recent_profile]
+    joined_id = ",".join(recent_profile_id)
+    recent_rooms = [int(i["id"]) for i in recent_profile]
     recent_list = None
     if joined_id:
         recent_list = Profile.objects.raw(
-            f'SELECT * from judge_profile where id in ({joined_id}) order by field(id,{joined_id})')
-    friend_list = Friend.get_friend_profiles(request.profile).exclude(id__in=recent_profile_id)\
-                    .exclude(id__in=ignored_users)\
-                    .order_by('-last_access')
-    admin_list = queryset.filter(display_rank='admin')\
-                .exclude(id__in=friend_list).exclude(id__in=recent_profile_id)
-    all_user_status = queryset\
-        .filter(display_rank='user',
-        last_access__gte = last_two_minutes)\
-        .annotate(is_online=Case(default=True,output_field=BooleanField()))\
-        .order_by('-rating').exclude(id__in=friend_list).exclude(id__in=admin_list)\
+            f"SELECT * from judge_profile where id in ({joined_id}) order by field(id,{joined_id})"
+        )
+    friend_list = (
+        Friend.get_friend_profiles(request.profile)
+        .exclude(id__in=recent_profile_id)
+        .exclude(id__in=ignored_users)
+        .order_by("-last_access")
+    )
+    admin_list = (
+        queryset.filter(display_rank="admin")
+        .exclude(id__in=friend_list)
+        .exclude(id__in=recent_profile_id)
+    )
+    all_user_status = (
+        queryset.filter(display_rank="user", last_access__gte=last_two_minutes)
+        .annotate(is_online=Case(default=True, output_field=BooleanField()))
+        .order_by("-rating")
+        .exclude(id__in=friend_list)
+        .exclude(id__in=admin_list)
         .exclude(id__in=recent_profile_id)[:30]
-    
+    )
+
     return [
         {
-            'title': 'Recent',
-            'user_list': get_online_status(request.profile, recent_list, recent_rooms),
+            "title": "Recent",
+            "user_list": get_online_status(request.profile, recent_list, recent_rooms),
         },
         {
-            'title': 'Following',
-            'user_list': get_online_status(request.profile, friend_list),
+            "title": "Following",
+            "user_list": get_online_status(request.profile, friend_list),
         },
         {
-            'title': 'Admin',
-            'user_list': get_online_status(request.profile, admin_list),
+            "title": "Admin",
+            "user_list": get_online_status(request.profile, admin_list),
         },
         {
-            'title': 'Other',
-            'user_list': get_online_status(request.profile, all_user_status),
+            "title": "Other",
+            "user_list": get_online_status(request.profile, all_user_status),
         },
     ]
 
 
 @login_required
 def online_status_ajax(request):
-    return render(request, 'chat/online_status.html', {
-            'status_sections': get_status_context(request),
-            'unread_count_lobby': get_unread_count(None, request.profile),
-        })
+    return render(
+        request,
+        "chat/online_status.html",
+        {
+            "status_sections": get_status_context(request),
+            "unread_count_lobby": get_unread_count(None, request.profile),
+        },
+    )
 
 
 @login_required
@@ -353,10 +409,10 @@ def get_room(user_one, user_two):
 
 @login_required
 def get_or_create_room(request):
-    if request.method == 'GET':
-        decrypted_other_id = request.GET.get('other')
-    elif request.method == 'POST':
-        decrypted_other_id = request.POST.get('other')
+    if request.method == "GET":
+        decrypted_other_id = request.GET.get("other")
+    elif request.method == "POST":
+        decrypted_other_id = request.POST.get("other")
     else:
         return HttpResponseBadRequest()
 
@@ -371,7 +427,7 @@ def get_or_create_room(request):
         return HttpResponseBadRequest()
 
     user = request.profile
-    
+
     if not other_user or not user:
         return HttpResponseBadRequest()
     # TODO: each user can only create <= 300 rooms
@@ -382,47 +438,60 @@ def get_or_create_room(request):
             user_room.last_seen = timezone.now()
             user_room.save()
 
-    if request.method == 'GET':
-        return JsonResponse({'room': room.id, 'other_user_id': other_user.id})
-    return HttpResponseRedirect(reverse('chat', kwargs={'room_id': room.id}))
+    if request.method == "GET":
+        return JsonResponse({"room": room.id, "other_user_id": other_user.id})
+    return HttpResponseRedirect(reverse("chat", kwargs={"room_id": room.id}))
 
 
 def get_unread_count(rooms, user):
     if rooms:
-        mess = Message.objects.filter(room=OuterRef('room'),
-                                      time__gte=OuterRef('last_seen'))\
-                .exclude(author=user)\
-                .order_by().values('room')\
-                .annotate(unread_count=Count('pk')).values('unread_count')
+        mess = (
+            Message.objects.filter(
+                room=OuterRef("room"), time__gte=OuterRef("last_seen")
+            )
+            .exclude(author=user)
+            .order_by()
+            .values("room")
+            .annotate(unread_count=Count("pk"))
+            .values("unread_count")
+        )
 
-        return UserRoom.objects\
-            .filter(user=user, room__in=rooms)\
+        return (
+            UserRoom.objects.filter(user=user, room__in=rooms)
             .annotate(
                 unread_count=Coalesce(Subquery(mess, output_field=IntegerField()), 0),
                 other_user=Case(
-                    When(room__user_one=user, then='room__user_two'),
-                    default='room__user_one',
-                )
-            ).filter(unread_count__gte=1).values('other_user', 'unread_count')
-    else: # lobby
-        mess = Message.objects.filter(room__isnull=True,
-                                      time__gte=OuterRef('last_seen'))\
-                .exclude(author=user)\
-                .order_by().values('room')\
-                .annotate(unread_count=Count('pk')).values('unread_count')
+                    When(room__user_one=user, then="room__user_two"),
+                    default="room__user_one",
+                ),
+            )
+            .filter(unread_count__gte=1)
+            .values("other_user", "unread_count")
+        )
+    else:  # lobby
+        mess = (
+            Message.objects.filter(room__isnull=True, time__gte=OuterRef("last_seen"))
+            .exclude(author=user)
+            .order_by()
+            .values("room")
+            .annotate(unread_count=Count("pk"))
+            .values("unread_count")
+        )
 
-        res = UserRoom.objects\
-            .filter(user=user, room__isnull=True)\
+        res = (
+            UserRoom.objects.filter(user=user, room__isnull=True)
             .annotate(
                 unread_count=Coalesce(Subquery(mess, output_field=IntegerField()), 0),
-            ).values_list('unread_count', flat=True)
+            )
+            .values_list("unread_count", flat=True)
+        )
 
         return res[0] if len(res) else 0
 
 
 @login_required
 def toggle_ignore(request, **kwargs):
-    user_id = kwargs['user_id']
+    user_id = kwargs["user_id"]
     if not user_id:
         return HttpResponseBadRequest()
     try:
@@ -431,28 +500,34 @@ def toggle_ignore(request, **kwargs):
         return HttpResponseBadRequest()
 
     Ignore.toggle_ignore(request.profile, other_user)
-    next_url = request.GET.get('next', '/')
+    next_url = request.GET.get("next", "/")
     return HttpResponseRedirect(next_url)
 
 
 @login_required
 def get_unread_boxes(request):
-    if (request.method != 'GET'):
+    if request.method != "GET":
         return HttpResponseBadRequest()
 
     ignored_users = Ignore.get_ignored_users(request.profile)
 
-    mess = Message.objects.filter(room=OuterRef('room'),
-                                  time__gte=OuterRef('last_seen'))\
-            .exclude(author=request.profile)\
-            .exclude(author__in=ignored_users)\
-            .order_by().values('room')\
-            .annotate(unread_count=Count('pk')).values('unread_count')
+    mess = (
+        Message.objects.filter(room=OuterRef("room"), time__gte=OuterRef("last_seen"))
+        .exclude(author=request.profile)
+        .exclude(author__in=ignored_users)
+        .order_by()
+        .values("room")
+        .annotate(unread_count=Count("pk"))
+        .values("unread_count")
+    )
 
-    unread_boxes = UserRoom.objects\
-        .filter(user=request.profile, room__isnull=False)\
+    unread_boxes = (
+        UserRoom.objects.filter(user=request.profile, room__isnull=False)
         .annotate(
             unread_count=Coalesce(Subquery(mess, output_field=IntegerField()), 0),
-        ).filter(unread_count__gte=1).count()
+        )
+        .filter(unread_count__gte=1)
+        .count()
+    )
 
-    return JsonResponse({'unread_boxes': unread_boxes})
+    return JsonResponse({"unread_boxes": unread_boxes})