clean: project is healthy now :)

chat/consumersChat.py

@@ -1,40 +1,37 @@
 from channels.generic.websocket import WebsocketConsumer
 from asgiref.sync import async_to_sync
 from .models import ChatMemberModel, ChatMessageModel
-from profiles.models import BlockModel
 
 import time
 import json
 
+
 class ChatConsumer(WebsocketConsumer):
 
     def connect(self):
 
-        user = self.scope["user"]
+        self.user = self.scope["user"]
-        if (user.is_anonymous or not user.is_authenticated):
+        if not self.user.is_authenticated:
             return
 
-        channel_id : int = int(self.scope['url_route']['kwargs']['chat_id'])
+        self.channel_id: int = int(self.scope['url_route']['kwargs']['chat_id'])
 
-        if ChatMemberModel.objects.filter(member_id=user.pk, channel_id=int(channel_id)).count() != 1:
+        if not ChatMemberModel.objects.filter(member_id=self.user.pk, channel_id=self.channel_id).exists():
             return
 
-        if (self.channel_layer == None):
+        if self.channel_layer is None:
             return
 
-        self.room_group_name = f'chat{channel_id}'
+        self.room_group_name = f'chat{self.channel_id}'
 
         async_to_sync(self.channel_layer.group_add)(
             self.room_group_name,
             self.channel_name
         )
-
         self.accept()
 
-
     def receive(self, text_data=None, bytes_data=None):
-
+        if text_data is None:
-        if text_data == None:
             return
 
         user = self.scope["user"]
@@ -44,208 +41,32 @@ class ChatConsumer(WebsocketConsumer):
         text_data_json: dict = json.loads(text_data)
 
         message = text_data_json.get('message')
-        if (message is None):
+        if message is None:
-            return
-        
-        receivers_id = text_data_json.get('receivers_id')
-        if (receivers_id is None):
-            return
-
-        channel_id : int = int(self.scope['url_route']['kwargs']['chat_id'])
-
-        if ChatMemberModel.objects.filter(member_id = user.pk, channel_id = channel_id).count() != 1:
-            return
-
-        if (self.channel_layer == None):
             return
 
         message_time: int = int(time.time() * 1000)
 
-        if (len(receivers_id) == 1 and 
-            BlockModel.objects.filter(blocker=user.pk, blocked=receivers_id[0]) or
-            BlockModel.objects.filter(blocker=receivers_id[0], blocked=user.pk)
-            ):
-            return
-
         async_to_sync(self.channel_layer.group_send)(
             self.room_group_name,
             {
-                'type':'chat_message',
+                'type': 'chat_message',
-                'author_id':user.pk,
+                'author_id': user.pk,
-                'content':message,
+                'content': message,
-                'time':message_time,
+                'time': message_time,
             }
         )
 
-        new_message = ChatMessageModel(
+        ChatMessageModel(
-                channel_id = channel_id, 
+            channel_id=self.channel_id,
-                author_id = user.pk, 
+            author_id=user.pk,
-                content = message, 
+            content=message,
-                time = message_time
+            time=message_time
         ).save()
 
     def chat_message(self, event):
-
-        user = self.scope["user"]
-        if (user.is_anonymous or not user.is_authenticated):
-            return
-
-        channel_id: int = int(self.scope['url_route']['kwargs']['chat_id'])
-
-        if ChatMemberModel.objects.filter(member_id=user.pk, channel_id=channel_id).count() != 1:
-            return
-
         self.send(text_data=json.dumps({
-            'type':'chat',
+            'type': 'chat',
-            'author_id':event['author_id'],
+            'author_id': event['author_id'],
-            'content':event['content'],
+            'content': event['content'],
             'time': event['time'],
         }))
-
-class ChatNoticeConsumer(WebsocketConsumer):
-
-    def connect(self):
-
-        user = self.scope["user"]
-        #if (user.is_anonymous or not user.is_authenticated):
-            #return
-
-        if (self.channel_layer == None):
-            return
-
-        self.room_group_name = f'chatNotice{user.pk}'
-        if (not hasattr(self.channel_layer, "users_channels")):
-            self.channel_layer.users_channels = {}
-        self.channel_layer.users_channels[user.pk] = self.channel_name
-
-        if (not hasattr(self.channel_layer, "invite")):
-            self.channel_layer.invite = {}
-        self.channel_layer.invite[user.pk] = [];
-
-        async_to_sync(self.channel_layer.group_add)(
-            self.room_group_name,
-            self.channel_name
-        )
-
-        self.accept()
-
-        message_time: int = int(time.time() * 1000)
-        targets = list(self.channel_layer.users_channels.keys())
-        for target in targets:
-            channel = self.channel_layer.users_channels.get(target)
-            if (channel == None or target == user.pk):
-                continue
-            async_to_sync(self.channel_layer.send)(channel, {
-                'type':"online_users",
-                'author_id':user.pk,
-                'time':message_time,
-            })
-
-    def disconnect(self, code):
-
-        user = self.scope["user"]
-        if (user.is_anonymous or not user.is_authenticated):
-            return    
-
-        self.channel_layer.users_channels.pop(user.pk)
-
-        message_time: int = int(time.time() * 1000)
-
-        targets = list(self.channel_layer.users_channels.keys())
-        for target in targets:
-            channel = self.channel_layer.users_channels.get(target)
-            if (channel == None or target == user.pk):
-                continue
-            async_to_sync(self.channel_layer.send)(channel, {
-                'type':"online_users",
-                'author_id':user.pk,
-                'time':message_time,
-            })
-
-    def receive(self, text_data=None, bytes_data=None):
-
-        if text_data == None:
-            return
-
-        user = self.scope["user"]
-        #if (user.is_anonymous or not user.is_authenticated):
-            #return
-
-        text_data_json = json.loads(text_data)
-        
-        type_notice = text_data_json.get('type')
-        targets : list = text_data_json.get('targets')
-        content : dict = text_data_json.get('content')
-
-        if (type_notice == None or targets == None):
-            return
-
-        if (self.channel_layer == None):
-            return
-
-        message_time: int = int(time.time() * 1000)
-        status = 200;
-
-        #print("receive" + str(user.pk))
-
-        if targets == "all":
-            targets = list(self.channel_layer.users_channels.keys())
-
-        for target in targets:
-            channel = self.channel_layer.users_channels.get(target)
-            if (channel == None or target == user.pk):
-                if (channel == None):
-                    status = 404
-                continue
-            async_to_sync(self.channel_layer.send)(channel, {
-                'type':type_notice,
-                'author_id':user.pk,
-                'content':content,
-                'time':message_time,
-                'status': 200,
-            })
-        async_to_sync(self.channel_layer.send)(self.channel_layer.users_channels.get(user.pk), {
-            'type':type_notice,
-            'author_id':user.pk,
-            'content':"notice return",
-            'time':message_time,
-            'status':status,
-        })
-
-
-
-    def invite(self, event):
-
-        user = self.scope["user"]
-        if (user.is_anonymous or not user.is_authenticated):
-            return
-
-        if (self.channel_layer.invite[event["author_id"]].get(user.pk)):
-            return
-        self.channel_layer.invite[event["author_id"]].append(user.pl)
-
-        self.send(text_data=json.dumps({
-            'type':event['type'],
-            'author_id':event['author_id'],
-            'content':event['content'],
-            'time': event['time'],
-            'status':event['status'],
-        }))
-
-    def online_users(self, event):
-
-        user = self.scope["user"]
-        #if (user.is_anonymous or not user.is_authenticated):
-            #return
-
-        #print("online_users" + str(user.pk))
-
-        event['content'] = self.channel_layer.users_channels
-
-        self.send(text_data=json.dumps({
-            'type':event['type'],
-            'author_id':event['author_id'],
-            'content':event['content'],
-            'time': event['time'],
-            'status':event['status'],
-        }))

chat/consumersNotice.py

@@ -1,379 +0,0 @@
-from channels.generic.websocket import WebsocketConsumer
-from asgiref.sync import async_to_sync
-
-from games.models import GameModel
-from profiles.models import FriendModel, AskFriendModel
-
-import time
-import json
-
-class ChatNoticeConsumer(WebsocketConsumer):
-
-    def connect(self):
-
-        user = self.scope["user"]
-        #if (user.is_anonymous or not user.is_authenticated):
-            #return
-
-        if (self.channel_layer == None):
-            return
-
-        self.room_group_name = f'chatNotice{user.pk}'
-        if (not hasattr(self.channel_layer, "users_channels")):
-            self.channel_layer.users_channels = {}
-        self.channel_layer.users_channels[user.pk] = self.channel_name
-
-        if (not hasattr(self.channel_layer, "invite")):
-            self.channel_layer.invite = {}
-        self.channel_layer.invite[user.pk] = [];
-
-        async_to_sync(self.channel_layer.group_add)(
-            self.room_group_name,
-            self.channel_name
-        )
-
-        self.accept()
-
-        self.sync()
-
-    def disconnect(self, code):
-
-        user = self.scope["user"]
-        if (user.is_anonymous or not user.is_authenticated):
-            return    
-
-        del self.channel_layer.users_channels[user.pk]
-        del self.channel_layer.invite[user.pk]
-
-        for inviter_id, inviteds_id in self.channel_layer.invite.items():
-            if (user.pk in inviteds_id): 
-                self.channel_layer.invite[inviter_id].remove(user.pk)
-
-        self.sync()
-
-
-    def receive(self, text_data=None, bytes_data=None):
-
-        if text_data == None:
-            return
-
-        user = self.scope["user"]
-        #if (user.is_anonymous or not user.is_authenticated):
-            #return
-
-        text_data_json = json.loads(text_data)
-        
-        type_notice = text_data_json.get('type')
-        targets : list = text_data_json.get('targets')
-        content : dict = text_data_json.get('content')
-
-        if (type_notice == None or targets == None):
-            return
-
-        if (self.channel_layer == None):
-            return
-
-        message_time: int = text_data_json.get('time')
-
-        if (message_time == None):
-            message_time: int = int(time.time() * 1000)
-
-        result = None
-        try:
-            status, result = getattr(self, "pre_" + type_notice)(user, targets)
-        except AttributeError as error:
-            status = 200
-
-        if (status < 300):
-            if targets == "all":
-                targets = list(self.channel_layer.users_channels.keys())
-
-            for target in targets:
-                channel = self.channel_layer.users_channels.get(target)
-                if (channel == None or target == user.pk):
-                    if (channel == None):
-                        status = 444 # target not connected
-                    continue
-                async_to_sync(self.channel_layer.send)(channel, {
-                    'type':type_notice,
-                    'author_id':user.pk,
-                    'content':content,
-                    'result':result,
-                    'targets': targets,
-                    'time':message_time,
-                    'status': 200,
-                })
-
-        async_to_sync(self.channel_layer.send)(self.channel_layer.users_channels.get(user.pk), {
-            'type':type_notice,
-            'author_id':user.pk,
-            'result':result,
-            'targets': targets,
-            'time':message_time,
-            'status':status,
-        })
-
-    def sync(self, user = None, level = None):
-        
-        sendToUser = True
-        if (user == None):
-            user = self.scope["user"]
-            sendToUser = False
-            
-
-        if (level == None):
-            level = 0
-
-        message_time: int = int(time.time() * 1000)
-        if (sendToUser):
-            targets = [user.pk]
-        else:
-            targets = list(self.channel_layer.users_channels.keys())
-
-        for target in targets:
-            channel = self.channel_layer.users_channels.get(target)
-            if (channel == None or (not sendToUser and target == user.pk)):
-                continue
-            async_to_sync(self.channel_layer.send)(channel, {
-                'type':"online_users",
-                'author_id':user.pk,
-                'targets': targets,
-                'time':message_time,
-                'status': 200,
-            })
-            if (level >= 1): 
-                async_to_sync(self.channel_layer.send)(channel, {
-                    'type':"invite",
-                    'author_id':user.pk,
-                    'targets': targets,
-                    'time':message_time,
-                    'status': 200,
-                })
-
-
-    def pre_invite(self, user, targets):
-
-        if (user.is_anonymous or not user.is_authenticated):
-            return 400, None
-
-        status = 200
-        for target in targets:
-            if (target in self.channel_layer.invite[user.pk]):
-                status = 409
-                continue
-
-            channel = self.channel_layer.users_channels.get(target)
-            if (channel == None):
-                status = 404
-                continue
-
-            # Add the invited in "self.channel_layer.invite"
-            if (user.pk != target):
-                self.channel_layer.invite[user.pk].append(target)
-
-        return status, None
-
-    def get_invites(self, user):
-        invites = []
-        for inviter_id, inviteds_id in self.channel_layer.invite.items():
-            if (user.pk in inviteds_id and user.pk != inviter_id): 
-                invites.append(inviter_id)
-        return invites;
-
-    def invite(self, event):
-
-        user = self.scope["user"]
-        if (user.is_anonymous or not user.is_authenticated):
-            return
-
-        invites = self.get_invites(user)
-
-        self.send(text_data=json.dumps({
-            'type':event['type'],
-            'author_id':event['author_id'],
-            'invites': invites,
-            'targets': event['targets'],
-            'time': event['time'],
-            'status':event['status'],
-        }))
-
-    def pre_accept_invite(self, user, targets):
-
-        if (user.is_anonymous or not user.is_authenticated):
-            return 400, None
-
-        if (user.pk not in self.channel_layer.invite[targets[0]]):
-            return 400, None
-
-        self.channel_layer.invite[targets[0]].remove(user.pk)
-
-        if (targets[0] in self.channel_layer.invite[user.pk]):
-            self.channel_layer.invite[user.pk].remove(targets[0])
-
-        id_game = GameModel().create("pong", [user.pk, targets[0]]);
-
-        return 200, id_game
-
-    def accept_invite(self, event):
-
-        user = self.scope["user"]
-        if (user.is_anonymous or not user.is_authenticated):
-            return
-
-        invites = self.get_invites(user)
-
-        self.send(text_data=json.dumps({
-            'type':event['type'],
-            'author_id':event['author_id'],
-            'id_game': event['result'],
-            'invites': invites,
-            'time': event['time'],
-            'status':event['status'],
-        }))
-
-    def pre_refuse_invite(self, user, targets):
-
-        if (user.is_anonymous or not user.is_authenticated):
-            return 400, None
-
-        if (user.pk not in self.channel_layer.invite[targets[0]]):
-            return 400, None
-
-        self.channel_layer.invite[targets[0]].remove(user.pk)
-
-        if (targets[0] in self.channel_layer.invite[user.pk]):
-            self.channel_layer.invite[user.pk].remove(targets[0])
-
-        return 200, None
-        
-    def refuse_invite(self, event):
-
-        user = self.scope["user"]
-        if (user.is_anonymous or not user.is_authenticated):
-            return
-
-        invites = self.get_invites(user)
-
-        self.send(text_data=json.dumps({
-            'type':event['type'],
-            'author_id':event['author_id'],
-            'invites': invites,
-            'time': event['time'],
-            'status':event['status'],
-        }))
-
-    def pre_ask_friend(self, user, targets):
-
-        if (user.is_anonymous or not user.is_authenticated):
-            return 400, None
-
-        if (AskFriendModel.objects.filter(asker=user.pk, asked=targets[0])):
-            return 409, None
-
-        if (FriendModel().isFriend(user.pk, targets[0])):
-            return 409, None
-
-        if (targets[0] != None):
-            AskFriendModel(asker=user.pk, asked=targets[0]).save()
-
-        return 200, None
-
-    def send_ask_friend(self, event):
-
-        user = self.scope["user"]
-        if (user.is_anonymous or not user.is_authenticated):
-            return
-
-        asked = AskFriendModel().getAsked(user.pk)
-        asker = AskFriendModel().getAsker(user.pk)
-
-        online_friends = self.get_online_friend(user)
-
-        self.send(text_data=json.dumps({
-            'type':event['type'],
-            'author_id':event['author_id'],
-            'targets':event['targets'],
-            'asker': asker,
-            'asked': asked,
-            'online': online_friends,
-            'time': event['time'],
-            'status':event['status'],
-        }))
-
-    def ask_friend(self, event):
-        self.send_ask_friend(event)
-
-    def delete_ask(self, asker, user_asked):
-        if (user_asked.is_anonymous or not user_asked.is_authenticated):
-            return 400, None
-
-        asked = user_asked.pk
-
-        if (not AskFriendModel.objects.filter(asker=asker, asked=asked)):
-            return 404, None
-
-        if (FriendModel().isFriend(asker, asked)):
-            return 409, None
-
-        if (not AskFriendModel().deleteAsk(asker, asked)):
-            return 400, None
-
-        return 200, None
-
-    def pre_accept_friend(self, user, targets):
-        status, result = self.delete_ask(targets[0], user)
-        
-        if (status == 200):
-            FriendModel(user_id1=user.pk, user_id2=targets[0]).save()
-        return status, result
-
-    def accept_friend(self, event):
-        self.send_ask_friend(event)
-
-    def pre_refuse_friend(self, user, targets):
-        return self.delete_ask(targets[0], user)
-
-    def refuse_friend(self, event):
-        self.send_ask_friend(event)
-
-    def pre_remove_friend(self, user, targets):
-
-        if (user.is_anonymous or not user.is_authenticated):
-            return 400, None
-        
-        if (not FriendModel().isFriend(user.pk, targets[0])):
-            return 409, None
-
-        if (not FriendModel().deleteFriend(user.pk, targets[0])):
-            return 400, None
-
-        return 200, None
-    
-    def remove_friend(self, event):
-        self.send_ask_friend(event)
-
-
-    def get_online_friend(self, user):
-        online_friends = {}
-        for friend in FriendModel().getFriends(user.pk):
-            if (friend in self.channel_layer.users_channels):
-                online_friends[friend] = "green"
-            else:
-                online_friends[friend] = "red"
-        return online_friends
-
-    def online_users(self, event):
-
-        user = self.scope["user"]
-        if (user.is_anonymous or not user.is_authenticated):
-            return
-
-        online_friends = self.get_online_friend(user)
-
-        self.send(text_data=json.dumps({
-            'type':event['type'],
-            'author_id':event['author_id'],
-            'online':online_friends,
-            'time': event['time'],
-            'status':event['status'],
-        }))

chat/routing.py

@@ -1,9 +1,7 @@
 from django.urls import re_path
 
 from . import consumersChat
-from . import consumersNotice
 
 websocket_urlpatterns = [
     re_path(r'ws/chat/(?P<chat_id>\d+)$', consumersChat.ChatConsumer.as_asgi()),
-    re_path(r'ws/chat/notice$', consumersNotice.ChatNoticeConsumer.as_asgi()),
 ]

chat/serializers.py

@@ -1,12 +1,14 @@
 from rest_framework import serializers
 
-from profiles.models import ProfileModel
+from django.utils.translation import gettext as _
 
+from profiles.models.ProfileModel import ProfileModel
 from .models import ChatChannelModel, ChatMessageModel
 
+
 class ChatChannelSerializer(serializers.ModelSerializer):
 
-    members_id = serializers.ListField(child = serializers.IntegerField())
+    members_id = serializers.ListField(child=serializers.IntegerField())
 
     class Meta:
         model = ChatChannelModel
@@ -15,14 +17,15 @@ class ChatChannelSerializer(serializers.ModelSerializer):
     def validate_members_id(self, value):
         members_id: [int] = value
         if len(members_id) < 2:
-            raise serializers.ValidationError('Not enought members to create the channel')
+            raise serializers.ValidationError(_('There is not enough members to create the channel.'))
         if len(set(members_id)) != len(members_id):
-            raise serializers.ValidationError('Same member')
+            raise serializers.ValidationError(_('Duplicate in members list.'))
         for member_id in members_id:
-            if not ProfileModel.objects.filter(pk = member_id).exists():
+            if not ProfileModel.objects.filter(pk=member_id).exists():
-                raise serializers.ValidationError(f"The profile {member_id} doesn't exists.")
+                raise serializers.ValidationError(_(f"The profile {member_id} doesn't exist."))
         return members_id
 
+
 class ChatMessageSerializer(serializers.Serializer):
 
     class Meta:

profiles/admin.py

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

profiles/models.py

@@ -1,108 +0,0 @@
-from django.contrib.auth.models import User
-from django.db import models
-from django.db.models.signals import post_save, pre_delete
-from django.dispatch import receiver
-
-from games.consumers import game_manager
-
-from os.path import splitext
-
-
-def upload_to(instance, filename: str):
-    return f"./profiles/static/avatars/{instance.pk}{splitext(filename)[1]}"
-
-
-class ProfileModel(models.Model):
-    user = models.ForeignKey(User, on_delete=models.CASCADE)
-    avatar = models.ImageField(upload_to=upload_to, default="./profiles/static/avatars/default.avif")
-
-    def get_game(self) -> int:
-        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
-
-
-@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 BlockModel(models.Model):
-    blocker = models.ForeignKey(User, on_delete=models.CASCADE, related_name='blocker')
-    blocked = models.ForeignKey(User, on_delete=models.CASCADE, related_name='blocked')
-
-
-class AskFriendModel(models.Model):
-    asker = models.IntegerField(primary_key=False)
-    asked = models.IntegerField(primary_key=False)
-
-    def getAsked(self, asker):
-        askeds = []
-
-        for ask in AskFriendModel.objects.filter(asker=asker):
-            askeds.append(ask.asked)
-
-        return askeds
-
-    def getAsker(self, asked):
-        askers = []
-
-        for ask in AskFriendModel.objects.filter(asked=asked):
-            askers.append(ask.asker)
-
-        return askers
-
-    def deleteAsk(self, asker, asked):
-
-        deleted = AskFriendModel.objects.filter(asker=asker, asked=asked)
-
-        if (deleted.count() == 0 or not deleted):
-            return False
-
-        deleted.delete()
-        return True
-
-
-class FriendModel(models.Model):
-    user_id1 = models.IntegerField(primary_key=False)
-    user_id2 = models.IntegerField(primary_key=False)
-
-    def getFriends(self, user_id):
-        friends = []
-
-        for friend in FriendModel.objects.filter(user_id1=user_id):
-            friends.append(friend.user_id2)
-
-        for friend in FriendModel.objects.filter(user_id2=user_id):
-            friends.append(friend.user_id1)
-
-        return friends
-
-    def isFriend(self, user_id1, user_id2):
-
-        return user_id2 in self.getFriends(user_id1)
-
-    def deleteFriend(self, user_id1, user_id2):
-
-        first = FriendModel.objects.filter(user_id1=user_id1, user_id2=user_id2)
-        if (first.count() == 1):
-            first.delete()
-            return True
-
-        second = FriendModel.objects.filter(user_id1=user_id2, user_id2=user_id1)
-        if (second.count() == 1):
-            second.delete()
-            return True
-
-        return False
-

profiles/models/BlockModel.py

@@ -0,0 +1,7 @@
+from django.db import models
+from django.contrib.auth.models import User
+
+
+class BlockModel(models.Model):
+    blocker = models.ForeignKey(User, on_delete=models.CASCADE, related_name='blocker')
+    blocked = models.ForeignKey(User, on_delete=models.CASCADE, related_name='blocked')

profiles/models/FriendModel.py

@@ -0,0 +1,7 @@
+from django.contrib.auth.models import User
+from django.db import models
+
+
+class FriendModel(models.Model):
+    friend1 = models.ForeignKey(User, on_delete=models.CASCADE, related_name='friend1')
+    friend2 = models.ForeignKey(User, on_delete=models.CASCADE, related_name='friend2')

profiles/models/ProfileModel.py

@@ -0,0 +1,53 @@
+from os.path import splitext
+
+from django.contrib.auth.models import User
+from django.db import models
+from django.db.models.signals import post_save, pre_delete
+from django.dispatch import receiver
+
+from games.consumers import game_manager
+from ..models.FriendModel import FriendModel
+
+
+def upload_to(instance, filename: str):
+    return f"./profiles/static/avatars/{instance.pk}{splitext(filename)[1]}"
+
+
+class ProfileModel(models.Model):
+    user = models.ForeignKey(User, on_delete=models.CASCADE)
+    avatar = models.ImageField(upload_to=upload_to, default="./profiles/static/avatars/default.avif")
+
+    def get_game(self) -> int:
+        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 getFriends(self):
+        friends = []
+
+        for friendship in FriendModel.objects.filter(models.Q(friend1=self.user) | models.Q(friend2=self.user)):
+            friends.append(friendship.friend1 if friendship.friend1 != self.user else friendship.friend2)
+
+        return friends
+
+    def isFriend(self, user):
+        return user in self.getFriends()
+
+    def deleteFriend(self, user):
+        for friendship in FriendModel.objects.filter(models.Q(friend1=self.user) | models.Q(friend2=self.user)):
+            friendship.delete()
+
+
+@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()

profiles/serializers/BlockSerializer.py

@@ -1,21 +0,0 @@
-from rest_framework.serializers import (ModelSerializer,
-                                        ReadOnlyField,
-                                        SerializerMethodField)
-
-from ..models import ProfileModel
-from ..models import BlockModel
-
-
-class BlockSerializer(ModelSerializer):
-    blocked_username = ReadOnlyField(source='blocked.username')
-    blocked_avatar = SerializerMethodField()
-
-    class Meta:
-        model = BlockModel
-        fields = ['blocked', 'blocked_username', 'blocked_avatar']
-
-    def get_blocked_avatar(self, instance):
-        blocked_profile = ProfileModel.objects.filter(user_id=instance.blocked.pk)
-        if (blocked_profile.exists()):
-            return blocked_profile[0].avatar.name
-        return '/static/avatars/default.avif'

profiles/serializers/ProfileSerializer.py

@@ -3,7 +3,7 @@ from django.utils.translation import gettext as _
 
 from rest_framework import serializers
 
-from ..models import ProfileModel
+from ..models.ProfileModel import ProfileModel
 
 
 class ProfileSerializer(serializers.ModelSerializer):

profiles/views/blocks.py

@@ -6,7 +6,8 @@ from rest_framework.authentication import SessionAuthentication
 from django.contrib.auth.models import User
 from django.utils.translation import gettext as _
 
-from ..models import BlockModel, ProfileModel
+from ..models.BlockModel import BlockModel
+from ..models.ProfileModel import ProfileModel
 from ..serializers.ProfileSerializer import ProfileSerializer
 
 

profiles/views/friends.py

@@ -2,8 +2,10 @@ 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 ..models import FriendModel
+
+from ..models.FriendModel import FriendModel
 
 
 class FriendsView(APIView):
@@ -11,7 +13,7 @@ class FriendsView(APIView):
     authentication_classes = (SessionAuthentication,)
 
     def get(self, request):
-        friends = FriendModel().getFriends(request.user.pk)
+        friends = FriendModel.getFriends(request.user.pk)
         if (friends):
             return Response({"friends": friends, "user_id": request.user.pk}, status=status.HTTP_200_OK)
         return Response({}, status=status.HTTP_204_NO_CONTENT)

profiles/viewsets/MyProfileViewSet.py

@@ -4,7 +4,7 @@ from rest_framework.response import Response
 from rest_framework.authentication import SessionAuthentication
 
 from ..serializers.ProfileSerializer import ProfileSerializer
-from ..models import ProfileModel
+from ..models.ProfileModel import ProfileModel
 
 
 class MyProfileViewSet(viewsets.ModelViewSet):

profiles/viewsets/ProfileViewSet.py

@@ -6,7 +6,7 @@ from rest_framework import viewsets
 from rest_framework.response import Response
 
 from ..serializers.ProfileSerializer import ProfileSerializer
-from ..models import ProfileModel
+from ..models.ProfileModel import ProfileModel
 
 
 class ProfileViewSet(viewsets.ModelViewSet):