dockered

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')