dockered

django/profiles/admin.py

@@ -0,0 +1,9 @@
+from django.contrib import admin
+
+from .models import ProfileModel, FriendModel, FriendRequestModel, BlockModel
+
+# Register your models here.
+admin.site.register(ProfileModel)
+admin.site.register(BlockModel)
+admin.site.register(FriendModel)
+admin.site.register(FriendRequestModel)

django/profiles/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class ProfilesConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'profiles'

django/profiles/models.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+from os.path import splitext
+
+from django.contrib.auth.models import User
+from django.db.models import Q, Model, CASCADE, ForeignKey, ImageField, OneToOneField
+from django.db.models.signals import post_save, pre_delete
+from django.dispatch import receiver
+
+
+def upload_to(instance, filename: str):
+    return f"./profiles/static/avatars/{instance.pk}{splitext(filename)[1]}"
+
+
+class ProfileModel(Model):
+    user = OneToOneField(User, on_delete=CASCADE)
+    avatar = ImageField(upload_to=upload_to, default="./profiles/static/avatars/default.avif")
+
+    def get_game(self) -> int:
+        from games.consumers import game_manager
+        for game in game_manager._game_list:
+            for player in game.get_players_connected():
+                if (player.user_id == self.user.pk):
+                    return game.game_id
+        return None
+
+    def get_friends(self) -> list[ProfileModel]:
+        friends: list[ProfileModel] = []
+
+        for friendship in FriendModel.objects.filter(Q(friend1=self) | Q(friend2=self)):
+            friends.append(friendship.friend1 if friendship.friend1 != self else friendship.friend2)
+
+        return friends
+
+    def is_friend(self, friend):
+        return FriendModel.objects.filter(
+            (Q(friend1=self) & Q(friend2=friend)) |
+            (Q(friend2=self) & Q(friend1=friend))
+        ).exists()
+
+    def delete_friend(self, friend):
+        FriendModel.objects.get(
+            (Q(friend1=self) & Q(friend2=friend)) |
+            (Q(friend2=self) & Q(friend1=friend))
+        ).delete()
+
+    def is_friend_requested_by(self, profile):
+        return FriendRequestModel.objects.filter(author=profile, target=self).exists()
+
+    def get_received_friend_request_from(self, profile):
+        return FriendRequestModel.objects.filter(author=profile, target=self).first()
+
+    def is_friend_requesting(self, profile):
+        return FriendRequestModel.objects.filter(author=self, target=profile).exists()
+
+    def get_outgoing_friend_request_to(self, profile):
+        return FriendRequestModel.objects.filter(author=self, target=profile).first()
+
+    def get_outgoing_friend_requests(self) -> list[ProfileModel]:
+        return FriendRequestModel.objects.filter(author=self)
+
+    def get_incoming_friend_requests(self) -> list[ProfileModel]:
+        return FriendRequestModel.objects.filter(target=self)
+
+
+@receiver(pre_delete, sender=ProfileModel)
+def delete_profile_picture(sender, instance, **kwargs):
+    if instance.avatar.name != './profiles/static/avatars/default.avif':
+        instance.avatar.storage.delete(instance.avatar.name)
+
+
+@receiver(post_save, sender=User)
+def on_user_created(sender, instance, created, **kwargs):
+    if created:
+        profile: ProfileModel = ProfileModel.objects.create(pk=instance.pk, user=instance)
+        profile.save()
+
+
+class FriendModel(Model):
+    friend1 = ForeignKey(ProfileModel, on_delete=CASCADE, related_name='friend1')
+    friend2 = ForeignKey(ProfileModel, on_delete=CASCADE, related_name='friend2')
+
+
+class FriendRequestModel(Model):
+    author = ForeignKey(ProfileModel, on_delete=CASCADE, related_name='author')
+    target = ForeignKey(ProfileModel, on_delete=CASCADE, related_name='target')
+
+    def accept(self):
+        FriendModel(friend1=self.author, friend2=self.target).save()
+        self.delete()
+
+
+class BlockModel(Model):
+    blocker = ForeignKey(ProfileModel, on_delete=CASCADE, related_name='blocker')
+    blocked = ForeignKey(ProfileModel, on_delete=CASCADE, related_name='blocked')

django/profiles/serializers.py

@@ -0,0 +1,67 @@
+from django.conf import settings
+from django.utils.translation import gettext as _
+
+from rest_framework import serializers
+
+from .models import ProfileModel
+
+
+class ProfileSerializer(serializers.ModelSerializer):
+
+    username = serializers.ReadOnlyField(source='user.username')
+    avatar = serializers.ImageField(required=False)
+    online = serializers.SerializerMethodField()
+    is_friend = serializers.SerializerMethodField()
+    has_incoming_request = serializers.SerializerMethodField()
+    has_outgoing_request = serializers.SerializerMethodField()
+
+    class Meta:
+        model = ProfileModel
+        fields = ["username", "avatar", "id", 'online', 'is_friend',
+                  'has_outgoing_request', 'has_incoming_request']
+
+    def get_online(self, obj: ProfileModel):
+        from notice.consumers import notice_manager
+
+        user = self.context.get('user')
+        if user is None or not user.is_authenticated:
+            return None
+
+        if not user.profilemodel.is_friend(obj) and user.pk != obj.pk:
+            return None
+
+        return notice_manager.get_consumer_by_user(obj.user) is not None
+
+    def get_is_friend(self, obj: ProfileModel):
+        user = self.context.get('user')
+        if user is None or not user.is_authenticated or user.pk == obj.pk:
+            return False
+
+        return obj.is_friend(user.profilemodel)
+
+    def get_has_incoming_request(self, obj: ProfileModel):
+        user = self.context.get('user')
+        if user is None or not user.is_authenticated or user.pk == obj.pk:
+            return False
+
+        return obj.is_friend_requesting(user.profilemodel)
+
+    def get_has_outgoing_request(self, obj: ProfileModel):
+        user = self.context.get('user')
+        if user is None or not user.is_authenticated or user.pk == obj.pk:
+            return False
+
+        return obj.is_friend_requested_by(user.profilemodel)
+
+    def validate_avatar(self, value):
+        '''
+        Check that the image is not too large
+        '''
+        if value.size > settings.PROFILE_PICTURE_MAX_SIZE:
+            raise serializers.ValidationError(_('Image is too large.'))
+        return value
+
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        data['avatar'] = data['avatar'][data['avatar'].find('/static/'):]
+        return data

django/profiles/tests/__init__.py

@@ -0,0 +1,2 @@
+from .blocks import *
+from .profiles import *

django/profiles/tests/blocks.py

@@ -0,0 +1,46 @@
+from django.test import TestCase
+from django.http import HttpResponse
+from django.contrib.auth.models import User
+from rest_framework import status
+
+from profiles.serializers.ProfileSerializer import ProfileSerializer
+from profiles.models.ProfileModel import ProfileModel
+
+
+class BlockTest(TestCase):
+    def setUp(self):
+        self.blocker_password = 'hello_world'
+        self.blocker: User = User.objects.create_user('blocker', password=self.blocker_password)
+        self.blocked: User = User.objects.create_user('blocked', password='password')
+        self.blocker.save()
+        self.blocked.save()
+
+    def test_normal(self):
+        self.client.login(username=self.blocker.username, password=self.blocker_password)
+        response: HttpResponse = self.client.post(f'/api/profiles/block/{self.blocked.pk}')
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
+        blocked_profile = ProfileModel.objects.get(user=self.blocked)
+
+        response = self.client.get('/api/profiles/block')
+        self.assertListEqual(response.json(), [ProfileSerializer(blocked_profile).data])
+    
+    def test_yourself(self):
+        self.client.login(username=self.blocker.username, password=self.blocker_password)
+        response: HttpResponse = self.client.post(f'/api/profiles/block/{self.blocker.pk}')
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+        response = self.client.get('/api/profiles/block')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertListEqual(response.json(), [])
+        
+    def test_user_not_found(self):
+        self.client.login(username=self.blocker.username, password=self.blocker_password)
+        response: HttpResponse = self.client.post(f'/api/profiles/block/23')
+
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+        response = self.client.get('/api/profiles/block')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertListEqual(response.json(), [])

django/profiles/tests/friends.py

@@ -0,0 +1,52 @@
+from django.test import TestCase
+from django.http import HttpResponse
+from django.contrib.auth.models import User
+from rest_framework import status
+
+from profiles.serializers.ProfileSerializer import ProfileSerializer
+from profiles.models.ProfileModel import ProfileModel
+
+
+class FriendTest(TestCase):
+    def setUp(self):
+        self.user_password = 'hello_world'
+        self.user: User = User.objects.create_user('blocker', password=self.user_password)
+        self.friend_password = "password"
+        self.friend: User = User.objects.create_user('blocked', password=self.friend_password)
+        self.user.save()
+        self.friend.save()
+        self.user_profile = ProfileModel.objects.get(user=self.user)
+        self.friend_profile = ProfileModel.objects.get(user=self.friend)
+
+
+    def test_normal(self):
+        self.client.login(username=self.user.username, password=self.user_password)
+
+        response: HttpResponse = self.client.post(f'/api/profiles/friends/{self.friend.pk}')
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
+        response = self.client.get('/api/profiles/friends')
+        self.assertListEqual(response.json(), [ProfileSerializer(self.friend_profile).data])
+
+        self.client.login(username=self.friend.username, password=self.friend_password)
+
+        response = self.client.get('/api/profiles/friends')
+        self.assertListEqual(response.json(), [ProfileSerializer(self.user_profile).data])
+    
+    def test_yourself(self):
+        self.client.login(username=self.user.username, password=self.user_password)
+
+        response: HttpResponse = self.client.post(f'/api/profiles/friends/{self.user.pk}')
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+        response = self.client.get('/api/profiles/friends')
+        self.assertListEqual(response.json(), [])
+        
+    def test_user_not_found(self):
+        self.client.login(username=self.user.username, password=self.user_password)
+
+        response: HttpResponse = self.client.post(f'/api/profiles/friends/32')
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+        response = self.client.get('/api/profiles/friends')
+        self.assertListEqual(response.json(), [])

django/profiles/tests/profiles.py

@@ -0,0 +1,16 @@
+from django.test import TestCase
+from django.http import HttpResponse
+from django.contrib.auth.models import User
+
+
+class ProfileTest(TestCase):
+    def setUp(self):
+        self.user: User = User.objects.create_user('bozo', password='password')
+        self.user.save()
+        self.expected_response = {'avatar': '/static/avatars/default.avif', 'user_id': 1, 'username': 'bozo'}
+
+        self.url = "/api/profiles/user/"
+
+    def test_profile_create_on_user_created(self):
+        response: HttpResponse = self.client.get(self.url + self.user.username)
+        self.assertDictEqual(self.expected_response, response.json())

django/profiles/urls.py

@@ -0,0 +1,23 @@
+from django.urls import path
+
+from .viewsets.ProfileViewSet import ProfileViewSet
+from .viewsets.MyProfileViewSet import MyProfileViewSet
+from .views.blocks import GetBlocksView, EditBlocksView
+from .views.friends import (GetFriendsView,
+                            EditFriendView,
+                            GetIncomingFriendRequestView,
+                            GetOutgoingFriendRequestView)
+
+urlpatterns = [
+    path("settings", MyProfileViewSet.as_view({'patch': 'partial_update', 'delete': 'delete_avatar'}), name="my_profile_page"),
+    path("me", MyProfileViewSet.as_view({'get': 'retrieve'}), name="my_profile_page"),
+    path("", ProfileViewSet.as_view({'get': 'list'}), name="profiles_list"),
+    path("block", GetBlocksView.as_view(), name="block_page"),
+    path("block/<int:pk>", EditBlocksView.as_view(), name="block_page"),
+    path("friends", GetFriendsView.as_view(), name="friends_list_page"),
+    path("friends/<int:pk>", EditFriendView.as_view(), name="friends_edit_page"),
+    path("incoming_friend_requests", GetIncomingFriendRequestView.as_view(), name="incoming_friend_requests"),
+    path("outgoing_friend_requests", GetOutgoingFriendRequestView.as_view(), name="outgoing_friend_requests"),
+    path("user/<str:username>", ProfileViewSet.as_view({'get': 'retrieve'}), name="profile_page"),
+    path("id/<int:pk>", ProfileViewSet.as_view({'get': 'retrieve_id'}), name="profile_page"),
+]

django/profiles/views/blocks.py

@@ -0,0 +1,57 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import permissions, status
+from rest_framework.authentication import SessionAuthentication
+from rest_framework.request import Request
+
+from django.utils.translation import gettext as _
+from django.shortcuts import get_object_or_404
+
+from ..models import BlockModel, ProfileModel
+from ..serializers import ProfileSerializer
+
+
+class GetBlocksView(APIView):
+    permission_classes = (permissions.IsAuthenticated,)
+    authentication_classes = (SessionAuthentication,)
+
+    def get(self, request: Request):
+        blocks = BlockModel.objects.filter(blocker=request.user.profilemodel)
+        bloked_profiles = [block.blocked for block in blocks]
+
+        return Response(ProfileSerializer(bloked_profiles, many=True).data)
+
+
+class EditBlocksView(APIView):
+    permission_classes = (permissions.IsAuthenticated,)
+    authentication_classes = (SessionAuthentication,)
+
+    def get_object(self):
+        return self.request.user.profilemodel
+
+    def post(self, request, pk=None):
+        user_profile = self.get_object()
+        blocked_profile = get_object_or_404(ProfileModel, pk=pk)
+
+        if user_profile.pk == pk:
+            return Response(_('You can\'t block yourself.'), status.HTTP_400_BAD_REQUEST)
+
+        if BlockModel.objects.filter(blocker=user_profile, blocked=blocked_profile):
+            return Response(_('You already blocked this user.'), status.HTTP_409_CONFLICT)
+
+        BlockModel(blocker=user_profile, blocked=blocked_profile).save()
+        return Response(_('User successfully blocked.'), status.HTTP_201_CREATED)
+
+    def delete(self, request, pk=None):
+        user_profile = self.get_object()
+        blocked_profile = get_object_or_404(ProfileModel, pk=pk)
+
+        if user_profile.pk == pk:
+            return Response(_('You can\'t unblock yourself.'), status.HTTP_400_BAD_REQUEST)
+
+        block_record = BlockModel.objects.filter(blocker=user_profile, blocked=blocked_profile).first()
+        if not block_record:
+            return Response(_('This user is not blocked.'), status.HTTP_400_BAD_REQUEST)
+
+        block_record.delete()
+        return Response(_('User successfully unblocked.'), status.HTTP_200_OK)

django/profiles/views/friends.py

@@ -0,0 +1,87 @@
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import permissions, status
+from rest_framework.authentication import SessionAuthentication
+
+from django.utils.translation import gettext as _
+from django.shortcuts import get_object_or_404
+
+from ..models import ProfileModel, FriendRequestModel
+from ..serializers import ProfileSerializer
+from notice.consumers import notice_manager
+
+
+class GetFriendsView(APIView):
+    permission_classes = (permissions.IsAuthenticated,)
+    authentication_classes = (SessionAuthentication,)
+
+    def get(self, request):
+        return Response(ProfileSerializer(request.user.profilemodel.get_friends(), many=True).data)
+
+
+class EditFriendView(APIView):
+    permission_classes = (permissions.IsAuthenticated,)
+    authentication_classes = (SessionAuthentication,)
+
+    def get_object(self):
+        return self.request.user.profilemodel
+
+    def post(self, request, pk=None):
+        user_profile: ProfileModel = self.get_object()
+        friend_profile = get_object_or_404(ProfileModel, pk=pk)
+
+        if user_profile.pk == pk:
+            return Response(_('You can\'t be friend with yourself.'), status.HTTP_400_BAD_REQUEST)
+
+        if user_profile.is_friend(friend_profile):
+            return Response(_('You are already friend with this user.'), status.HTTP_400_BAD_REQUEST)
+
+        if user_profile.is_friend_requesting(friend_profile):
+            return Response(_('You already sent a request to this user.'), status.HTTP_400_BAD_REQUEST)
+
+        incoming_request = user_profile.get_received_friend_request_from(friend_profile)
+        if incoming_request:
+            incoming_request.accept()
+            notice_manager.notify_new_friend(friend_profile.user, user_profile)
+            return Response(_('Friendship successfully created.'), status.HTTP_201_CREATED)
+
+        FriendRequestModel(author=user_profile, target=friend_profile).save()
+        notice_manager.notify_friend_request(friend_profile.user, user_profile)
+        return Response(_('Friend request sent.'), status.HTTP_200_OK)
+
+    def delete(self, request, pk=None):
+        user_profile = self.get_object()
+        friend_profile = get_object_or_404(ProfileModel, pk=pk)
+
+        outgoing_request = user_profile.get_outgoing_friend_request_to(friend_profile)
+        if outgoing_request:
+            outgoing_request.delete()
+            notice_manager.notify_friend_request_canceled(friend_profile.user, user_profile)
+            return Response(_('Friend request cancelled.'))
+
+        if not user_profile.is_friend(friend_profile):
+            return Response(_('You are not friend with this user.'), status.HTTP_400_BAD_REQUEST)
+
+        user_profile.delete_friend(friend_profile)
+        notice_manager.notify_friend_removed(friend_profile.user, user_profile)
+        return Response(_('Friendship successfully deleted.'), status.HTTP_201_CREATED)
+
+
+class GetIncomingFriendRequestView(APIView):
+    permission_classes = (permissions.IsAuthenticated,)
+    authentication_classes = (SessionAuthentication,)
+
+    def get(self, request):
+        requests = request.user.profilemodel.get_incoming_friend_requests()
+        profiles = [request.author for request in requests]
+        return Response(ProfileSerializer(profiles, many=True).data)
+
+
+class GetOutgoingFriendRequestView(APIView):
+    permission_classes = (permissions.IsAuthenticated,)
+    authentication_classes = (SessionAuthentication,)
+
+    def get(self, request):
+        requests = request.user.profilemodel.get_outgoing_friend_requests()
+        profiles = [request.target for request in requests]
+        return Response(ProfileSerializer(profiles, many=True).data)

django/profiles/viewsets/MyProfileViewSet.py

@@ -0,0 +1,38 @@
+from rest_framework import permissions
+from rest_framework import viewsets
+from rest_framework.response import Response
+from rest_framework.authentication import SessionAuthentication
+
+from ..serializers import ProfileSerializer
+from ..models import ProfileModel
+
+
+class MyProfileViewSet(viewsets.ModelViewSet):
+    permission_classes = (permissions.IsAuthenticated,)
+    authentication_classes = (SessionAuthentication,)
+    serializer_class = ProfileSerializer
+    queryset = ProfileModel.objects.all()
+
+    def get_object(self):
+        return self.request.user.profilemodel
+
+    def perform_update(self, serializer: ProfileSerializer, pk=None):
+        serializer.is_valid(raise_exception=True)
+        avatar = serializer.validated_data.get('avatar')
+        profile: ProfileModel = self.get_object()
+
+        if (avatar is not None):
+            if (profile.avatar.name != "./profiles/static/avatars/default.avif"):
+                profile.avatar.storage.delete(profile.avatar.name)
+            serializer.save()
+
+    def delete_avatar(self, pk=None):
+        profile = self.get_object()
+        if (profile.avatar.name != './profiles/static/avatars/default.avif'):
+            profile.avatar.storage.delete(profile.avatar.name)
+        profile.avatar.name = './profiles/static/avatars/default.avif'
+        profile.save()
+        return Response(ProfileSerializer(profile).data)
+
+    def retrieve(self, pk=None):
+        return Response(self.serializer_class(self.get_object(), context={'user': self.request.user}).data)

django/profiles/viewsets/ProfileViewSet.py

@@ -0,0 +1,27 @@
+from django.contrib.auth.models import User
+from django.shortcuts import get_object_or_404
+
+from rest_framework import permissions
+from rest_framework import viewsets
+from rest_framework.response import Response
+
+from ..serializers import ProfileSerializer
+from ..models import ProfileModel
+
+
+class ProfileViewSet(viewsets.ModelViewSet):
+    queryset = ProfileModel.objects.all()
+    serializer_class = ProfileSerializer
+    permission_classes = (permissions.IsAuthenticatedOrReadOnly,)
+
+    def retrieve(self, request, username=None):
+        user = get_object_or_404(User, username=username)
+        return Response(self.serializer_class(user.profilemodel, context={'user': request.user}).data)
+
+    def retrieve_id(self, request, pk=None):
+        user = get_object_or_404(User, pk=pk)
+        return Response(self.serializer_class(user.profilemodel, context={'user': request.user}).data)
+
+    def list(self, request):
+        serializer = ProfileSerializer(self.get_queryset(), many=True, context={'user': request.user})
+        return Response(serializer.data)