diff --git a/accounts/serializers/login.py b/accounts/serializers/login.py index 9fcbaff..b38fead 100644 --- a/accounts/serializers/login.py +++ b/accounts/serializers/login.py @@ -4,9 +4,9 @@ from django.core.exceptions import ValidationError class LoginSerializer(Serializer): - username = CharField() - password = CharField() + username = CharField() + password = CharField() - def get_user(self, data): - user = authenticate(username=data['username'], password=data['password']) - return user \ No newline at end of file + def get_user(self, data): + user = authenticate(username=data['username'], password=data['password']) + return user \ No newline at end of file diff --git a/accounts/views/delete.py b/accounts/views/delete.py index 9a83800..1333f7e 100644 --- a/accounts/views/delete.py +++ b/accounts/views/delete.py @@ -6,16 +6,16 @@ from django.http import HttpRequest from rest_framework.authentication import SessionAuthentication class DeleteView(APIView): - permission_classes = (permissions.IsAuthenticated,) - authentication_classes = (SessionAuthentication,) - def delete(self, request: HttpRequest): - data: dict = request.data + permission_classes = (permissions.IsAuthenticated,) + authentication_classes = (SessionAuthentication,) + def delete(self, request: HttpRequest): + data: dict = request.data - password: str = data["password"] - if (password is None): - return Response({"password": ["This field may not be blank."]}) - if (request.user.check_password(password) == False): - return Response({"password": ["Password wrong."]}) - request.user.delete() - logout(request) - return Response("user deleted", status=status.HTTP_200_OK) \ No newline at end of file + password: str = data["password"] + if (password is None): + return Response({"password": ["This field may not be blank."]}) + if (request.user.check_password(password) == False): + return Response({"password": ["Password wrong."]}) + request.user.delete() + logout(request) + return Response("user deleted", status=status.HTTP_200_OK) \ No newline at end of file diff --git a/accounts/views/logged.py b/accounts/views/logged.py index 1cc9cce..b67abe4 100644 --- a/accounts/views/logged.py +++ b/accounts/views/logged.py @@ -9,8 +9,8 @@ from ..serializers.login import LoginSerializer class LoggedView(APIView): - permission_classes = (permissions.AllowAny,) - authentication_classes = (SessionAuthentication,) + permission_classes = (permissions.AllowAny,) + authentication_classes = (SessionAuthentication,) - def get(self, request: HttpRequest): - return Response(status = (status.HTTP_200_OK if request.user.is_authenticated else status.HTTP_400_BAD_REQUEST)) + def get(self, request: HttpRequest): + return Response(status = (status.HTTP_200_OK if request.user.is_authenticated else status.HTTP_400_BAD_REQUEST)) diff --git a/accounts/views/login.py b/accounts/views/login.py index de5181f..d981f41 100644 --- a/accounts/views/login.py +++ b/accounts/views/login.py @@ -10,15 +10,15 @@ from ..serializers.login import LoginSerializer class LoginView(APIView): - permission_classes = (permissions.AllowAny,) - authentication_classes = (SessionAuthentication,) + permission_classes = (permissions.AllowAny,) + authentication_classes = (SessionAuthentication,) - def post(self, request: HttpRequest): - data = request.data - serializer = LoginSerializer(data=data) - serializer.is_valid(raise_exception=True) - user = serializer.get_user(data) - if user is None: - return Response({'login': [_('Invalid username or password.')]}, status.HTTP_401_UNAUTHORIZED) - login(request, user) - return Response({'id': user.pk}, status=status.HTTP_200_OK) + def post(self, request: HttpRequest): + data = request.data + serializer = LoginSerializer(data=data) + serializer.is_valid(raise_exception=True) + user = serializer.get_user(data) + if user is None: + return Response({'login': [_('Invalid username or password.')]}, status.HTTP_401_UNAUTHORIZED) + login(request, user) + return Response({'id': user.pk}, status=status.HTTP_200_OK) diff --git a/accounts/views/logout.py b/accounts/views/logout.py index f64e5b1..cee8868 100644 --- a/accounts/views/logout.py +++ b/accounts/views/logout.py @@ -6,8 +6,8 @@ from django.http import HttpRequest from rest_framework.authentication import SessionAuthentication class LogoutView(APIView): - permission_classes = (permissions.IsAuthenticated,) - authentication_classes = (SessionAuthentication,) - def get(self, request: HttpRequest): - logout(request) - return Response("user unlogged", status=status.HTTP_200_OK) \ No newline at end of file + permission_classes = (permissions.IsAuthenticated,) + authentication_classes = (SessionAuthentication,) + def get(self, request: HttpRequest): + logout(request) + return Response("user unlogged", status=status.HTTP_200_OK) \ No newline at end of file diff --git a/accounts/views/register.py b/accounts/views/register.py index 667ef2a..903609a 100644 --- a/accounts/views/register.py +++ b/accounts/views/register.py @@ -6,13 +6,13 @@ from django.http import HttpRequest from django.contrib.auth import login class RegisterView(APIView): - permission_classes = (permissions.AllowAny,) - def post(self, request: HttpRequest): - data = request.data - serializer = RegisterSerialiser(data=data) - if serializer.is_valid(raise_exception=True): - user = serializer.create(data) - if user: - login(request, user) - return Response("user created", status=status.HTTP_201_CREATED) - return Response(status=status.HTTP_400_BAD_REQUEST) + permission_classes = (permissions.AllowAny,) + def post(self, request: HttpRequest): + data = request.data + serializer = RegisterSerialiser(data=data) + if serializer.is_valid(raise_exception=True): + user = serializer.create(data) + if user: + login(request, user) + return Response("user created", status=status.HTTP_201_CREATED) + return Response(status=status.HTTP_400_BAD_REQUEST) diff --git a/chat/consumersChat.py b/chat/consumersChat.py index 2de3c68..289fe7c 100644 --- a/chat/consumersChat.py +++ b/chat/consumersChat.py @@ -8,244 +8,244 @@ import json class ChatConsumer(WebsocketConsumer): - def connect(self): + def connect(self): - user = self.scope["user"] - if (user.is_anonymous or not user.is_authenticated): - return + 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']) + 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: - return + if ChatMemberModel.objects.filter(member_id=user.pk, channel_id=int(channel_id)).count() != 1: + return - if (self.channel_layer == None): - return + if (self.channel_layer == None): + return - self.room_group_name = f'chat{channel_id}' + self.room_group_name = f'chat{channel_id}' - async_to_sync(self.channel_layer.group_add)( - self.room_group_name, - self.channel_name - ) + async_to_sync(self.channel_layer.group_add)( + self.room_group_name, + self.channel_name + ) - self.accept() + self.accept() - def receive(self, text_data=None, bytes_data=None): + def receive(self, text_data=None, bytes_data=None): - if text_data == None: - return + if text_data == None: + return - user = self.scope["user"] - if (user.is_anonymous or not user.is_authenticated): - return + user = self.scope["user"] + if (user.is_anonymous or not user.is_authenticated): + return - text_data_json: dict = json.loads(text_data) - - message = text_data_json.get('message') - if (message is None): - return - - receivers_id = text_data_json.get('receivers_id') - if (receivers_id is None): - return + text_data_json: dict = json.loads(text_data) + + message = text_data_json.get('message') + 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']) + 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 ChatMemberModel.objects.filter(member_id = user.pk, channel_id = channel_id).count() != 1: + return - if (self.channel_layer == None): - 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 + 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', - 'author_id':user.pk, - 'content':message, - 'time':message_time, - } - ) - - new_message = ChatMessageModel( - channel_id = channel_id, - author_id = user.pk, - content = message, - time = message_time - ).save() + async_to_sync(self.channel_layer.group_send)( + self.room_group_name, + { + 'type':'chat_message', + 'author_id':user.pk, + 'content':message, + 'time':message_time, + } + ) + + new_message = ChatMessageModel( + channel_id = channel_id, + author_id = user.pk, + content = message, + time = message_time + ).save() - def chat_message(self, event): + def chat_message(self, event): - user = self.scope["user"] - if (user.is_anonymous or not user.is_authenticated): - return + 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']) + 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 ChatMemberModel.objects.filter(member_id=user.pk, channel_id=channel_id).count() != 1: + return - self.send(text_data=json.dumps({ - 'type':'chat', - 'author_id':event['author_id'], - 'content':event['content'], - 'time': event['time'], - })) + self.send(text_data=json.dumps({ + 'type':'chat', + 'author_id':event['author_id'], + 'content':event['content'], + 'time': event['time'], + })) class ChatNoticeConsumer(WebsocketConsumer): - def connect(self): + def connect(self): - user = self.scope["user"] - #if (user.is_anonymous or not user.is_authenticated): - #return + user = self.scope["user"] + #if (user.is_anonymous or not user.is_authenticated): + #return - if (self.channel_layer == None): - 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 + 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] = []; + 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 - ) + async_to_sync(self.channel_layer.group_add)( + self.room_group_name, + self.channel_name + ) - self.accept() + 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, - }) + 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): + def disconnect(self, code): - user = self.scope["user"] - if (user.is_anonymous or not user.is_authenticated): - return + user = self.scope["user"] + if (user.is_anonymous or not user.is_authenticated): + return - self.channel_layer.users_channels.pop(user.pk) + self.channel_layer.users_channels.pop(user.pk) - message_time: int = int(time.time() * 1000) + 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, - }) + 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): + def receive(self, text_data=None, bytes_data=None): - if text_data == None: - return + if text_data == None: + return - user = self.scope["user"] - #if (user.is_anonymous or not user.is_authenticated): - #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') + 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 (type_notice == None or targets == None): + return - if (self.channel_layer == None): - return + if (self.channel_layer == None): + return - message_time: int = int(time.time() * 1000) - status = 200; + message_time: int = int(time.time() * 1000) + status = 200; - #print("receive" + str(user.pk)) + #print("receive" + str(user.pk)) - if targets == "all": - targets = list(self.channel_layer.users_channels.keys()) + 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, - }) + 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): + def invite(self, event): - user = self.scope["user"] - if (user.is_anonymous or not user.is_authenticated): - return + 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) + 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'], - })) + 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): + def online_users(self, event): - user = self.scope["user"] - #if (user.is_anonymous or not user.is_authenticated): - #return + user = self.scope["user"] + #if (user.is_anonymous or not user.is_authenticated): + #return - #print("online_users" + str(user.pk)) + #print("online_users" + str(user.pk)) - event['content'] = self.channel_layer.users_channels + 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'], - })) + self.send(text_data=json.dumps({ + 'type':event['type'], + 'author_id':event['author_id'], + 'content':event['content'], + 'time': event['time'], + 'status':event['status'], + })) diff --git a/chat/consumersNotice.py b/chat/consumersNotice.py index 536cdf3..1070c8e 100644 --- a/chat/consumersNotice.py +++ b/chat/consumersNotice.py @@ -9,371 +9,371 @@ import json class ChatNoticeConsumer(WebsocketConsumer): - def connect(self): + def connect(self): - user = self.scope["user"] - #if (user.is_anonymous or not user.is_authenticated): - #return + 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 (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]) + if (targets[0] in self.channel_layer.invite[user.pk]): + self.channel_layer.invite[user.pk].remove(targets[0]) - id_game = GameModel().create([user.pk, targets[0]]); + id_game = GameModel().create([user.pk, targets[0]]); - return 200, id_game + return 200, id_game - def accept_invite(self, event): + def accept_invite(self, event): - user = self.scope["user"] - if (user.is_anonymous or not user.is_authenticated): - return + user = self.scope["user"] + if (user.is_anonymous or not user.is_authenticated): + return - invites = self.get_invites(user) + 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'], - })) + 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): + def pre_refuse_invite(self, user, targets): - if (user.is_anonymous or not user.is_authenticated): - return 400, None + 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 + if (user.pk not in self.channel_layer.invite[targets[0]]): + return 400, None - self.channel_layer.invite[targets[0]].remove(user.pk) + 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]) + 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): + return 200, None + + def refuse_invite(self, event): - user = self.scope["user"] - if (user.is_anonymous or not user.is_authenticated): - return + user = self.scope["user"] + if (user.is_anonymous or not user.is_authenticated): + return - invites = self.get_invites(user) + 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'], - })) + 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): + def pre_ask_friend(self, user, targets): - if (user.is_anonymous or not user.is_authenticated): - return 400, None + 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 (AskFriendModel.objects.filter(asker=user.pk, asked=targets[0])): + return 409, None - if (FriendModel().isFriend(user.pk, 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() + if (targets[0] != None): + AskFriendModel(asker=user.pk, asked=targets[0]).save() - return 200, None + return 200, None - def send_ask_friend(self, event): + def send_ask_friend(self, event): - user = self.scope["user"] - if (user.is_anonymous or not user.is_authenticated): - return + user = self.scope["user"] + if (user.is_anonymous or not user.is_authenticated): + return - asked = AskFriendModel().getAsked(user.pk) - asker = AskFriendModel().getAsker(user.pk) + asked = AskFriendModel().getAsked(user.pk) + asker = AskFriendModel().getAsker(user.pk) - online_friends = self.get_online_friend(user) + 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'], - })) + 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 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 + 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 + asked = user_asked.pk - if (not AskFriendModel.objects.filter(asker=asker, asked=asked)): - return 404, None + if (not AskFriendModel.objects.filter(asker=asker, asked=asked)): + return 404, None - if (FriendModel().isFriend(asker, asked)): - return 409, None + if (FriendModel().isFriend(asker, asked)): + return 409, None - if (not AskFriendModel().deleteAsk(asker, asked)): - return 400, None + if (not AskFriendModel().deleteAsk(asker, asked)): + return 400, None - return 200, 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 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 accept_friend(self, event): + self.send_ask_friend(event) - def pre_refuse_friend(self, user, targets): - return self.delete_ask(targets[0], user) + 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 refuse_friend(self, event): + self.send_ask_friend(event) - def pre_remove_friend(self, user, targets): + 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 (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 + if (not FriendModel().deleteFriend(user.pk, targets[0])): + return 400, None - return 200, None - - def remove_friend(self, event): - self.send_ask_friend(event) + 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 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): + def online_users(self, event): - user = self.scope["user"] - if (user.is_anonymous or not user.is_authenticated): - return + user = self.scope["user"] + if (user.is_anonymous or not user.is_authenticated): + return - online_friends = self.get_online_friend(user) + 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'], - })) + self.send(text_data=json.dumps({ + 'type':event['type'], + 'author_id':event['author_id'], + 'online':online_friends, + 'time': event['time'], + 'status':event['status'], + })) diff --git a/chat/models.py b/chat/models.py index d8eb491..a53d15c 100644 --- a/chat/models.py +++ b/chat/models.py @@ -5,28 +5,28 @@ from django.contrib import admin # Create your models here. class ChatChannelModel(models.Model): - - def create(self, users_id: [int]): - self.save() - for user_id in users_id: - ChatMemberModel(channel_id = self.pk, member_id = user_id).save() - return self.pk + + def create(self, users_id: [int]): + self.save() + for user_id in users_id: + ChatMemberModel(channel_id = self.pk, member_id = user_id).save() + return self.pk - def get_members_id(self): - return [member_channel.member_id for member_channel in ChatMemberModel.objects.filter(channel_id = self.pk)] + def get_members_id(self): + return [member_channel.member_id for member_channel in ChatMemberModel.objects.filter(channel_id = self.pk)] class ChatMemberModel(models.Model): - member_id = IntegerField(primary_key=False) - channel_id = IntegerField(primary_key=False) + member_id = IntegerField(primary_key=False) + channel_id = IntegerField(primary_key=False) - def __str__(self): - return "member_id: " + str(self.member_id) + ", channel_id: " + str(self.channel_id) + def __str__(self): + return "member_id: " + str(self.member_id) + ", channel_id: " + str(self.channel_id) class ChatMessageModel(models.Model): - channel_id = IntegerField(primary_key=False) - author_id = IntegerField(primary_key=False) - content = models.CharField(max_length=255) - time = IntegerField(primary_key=False) + channel_id = IntegerField(primary_key=False) + author_id = IntegerField(primary_key=False) + content = models.CharField(max_length=255) + time = IntegerField(primary_key=False) - def __str__(self): - return "author_id: " + str(self.author_id) + ", channel_id: " + str(self.channel_id) + ", content: " + self.content + def __str__(self): + return "author_id: " + str(self.author_id) + ", channel_id: " + str(self.channel_id) + ", content: " + self.content diff --git a/chat/routing.py b/chat/routing.py index 6b8fc6f..642f6c0 100644 --- a/chat/routing.py +++ b/chat/routing.py @@ -4,6 +4,6 @@ from . import consumersChat from . import consumersNotice websocket_urlpatterns = [ - re_path(r'ws/chat/(?P\d+)$', consumersChat.ChatConsumer.as_asgi()), - re_path(r'ws/chat/notice$', consumersNotice.ChatNoticeConsumer.as_asgi()), + re_path(r'ws/chat/(?P\d+)$', consumersChat.ChatConsumer.as_asgi()), + re_path(r'ws/chat/notice$', consumersNotice.ChatNoticeConsumer.as_asgi()), ] diff --git a/chat/tests.py b/chat/tests.py index cf0ee9f..6be487e 100644 --- a/chat/tests.py +++ b/chat/tests.py @@ -6,25 +6,25 @@ from django.contrib.auth.models import User # Create your tests here. class ChatTest(TestCase): - def setUp(self): - self.client = Client() + def setUp(self): + self.client = Client() - self.username='bozo1' - self.password='password' + self.username='bozo1' + self.password='password' - self.user: User = User.objects.create_user(username=self.username, password=self.password) + self.user: User = User.objects.create_user(username=self.username, password=self.password) - self.dest: User = User.objects.create_user(username="bozo2", password=self.password) + self.dest: User = User.objects.create_user(username="bozo2", password=self.password) - self.url = "/api/chat/" + self.url = "/api/chat/" - def test_create_chat(self): - self.client.login(username=self.username, password=self.password) - response: HttpResponse = self.client.post(self.url + str(self.user.pk), {"members_id": [self.user.pk, self.dest.pk]}) - response_dict: dict = eval(response.content) - self.assertDictEqual(response_dict, {}) + def test_create_chat(self): + self.client.login(username=self.username, password=self.password) + response: HttpResponse = self.client.post(self.url + str(self.user.pk), {"members_id": [self.user.pk, self.dest.pk]}) + response_dict: dict = eval(response.content) + self.assertDictEqual(response_dict, {}) - def test_create_chat_unlogged(self): - response: HttpResponse = self.client.post(self.url + str(self.user.pk), {"members_id": [self.user.pk, self.dest.pk]}) - response_dict: dict = eval(response.content) - self.assertDictEqual(response_dict, {'detail': 'Authentication credentials were not provided.'}) + def test_create_chat_unlogged(self): + response: HttpResponse = self.client.post(self.url + str(self.user.pk), {"members_id": [self.user.pk, self.dest.pk]}) + response_dict: dict = eval(response.content) + self.assertDictEqual(response_dict, {'detail': 'Authentication credentials were not provided.'}) diff --git a/chat/views.py b/chat/views.py index 125d728..4b73cbf 100644 --- a/chat/views.py +++ b/chat/views.py @@ -14,35 +14,35 @@ from .serializers import ChatChannelSerializer, ChatMessageSerializer class ChannelView(APIView): - queryset = ChatChannelModel.objects - serializer_class = ChatChannelSerializer - permission_classes = (permissions.IsAuthenticated,) - authentication_classes = (SessionAuthentication,) + queryset = ChatChannelModel.objects + serializer_class = ChatChannelSerializer + permission_classes = (permissions.IsAuthenticated,) + authentication_classes = (SessionAuthentication,) - def post(self, request): + def post(self, request): - serializer = self.serializer_class(data = request.data) - - serializer.is_valid(raise_exception=True) + serializer = self.serializer_class(data = request.data) + + serializer.is_valid(raise_exception=True) - data: dict = serializer.validated_data + data: dict = serializer.validated_data - members_id = data.get("members_id") - if members_id == None: - return Response({"detail": "members_id is None."}, status = status.HTTP_400_BAD_REQUEST) + members_id = data.get("members_id") + if members_id == None: + return Response({"detail": "members_id is None."}, status = status.HTTP_400_BAD_REQUEST) - if self.request.user.pk not in members_id: - return Response({"detail": "You are trying to create a chat group without you."}, status = status.HTTP_400_BAD_REQUEST) + if self.request.user.pk not in members_id: + return Response({"detail": "You are trying to create a chat group without you."}, status = status.HTTP_400_BAD_REQUEST) - for member_channel in ChatMemberModel.objects.filter(member_id = members_id[0]): - channel_id: int = member_channel.channel_id - if not ChatChannelModel.objects.filter(pk = channel_id).exists(): - continue - channel: ChatChannelModel = ChatChannelModel.objects.get(pk = channel_id) - if set(channel.get_members_id()) == set(members_id): - messages = ChatMessageModel.objects.filter(channel_id = channel_id).order_by("time") - messages = serializers.serialize("json", messages) - return Response({'channel_id': channel_id, 'messages': messages}, status=status.HTTP_200_OK) + for member_channel in ChatMemberModel.objects.filter(member_id = members_id[0]): + channel_id: int = member_channel.channel_id + if not ChatChannelModel.objects.filter(pk = channel_id).exists(): + continue + channel: ChatChannelModel = ChatChannelModel.objects.get(pk = channel_id) + if set(channel.get_members_id()) == set(members_id): + messages = ChatMessageModel.objects.filter(channel_id = channel_id).order_by("time") + messages = serializers.serialize("json", messages) + return Response({'channel_id': channel_id, 'messages': messages}, status=status.HTTP_200_OK) - new_channel_id = ChatChannelModel().create(members_id) - return Response({'channel_id': new_channel_id}, status=status.HTTP_201_CREATED) + new_channel_id = ChatChannelModel().create(members_id) + return Response({'channel_id': new_channel_id}, status=status.HTTP_201_CREATED) diff --git a/games/models.py b/games/models.py index 9641af5..a470478 100644 --- a/games/models.py +++ b/games/models.py @@ -3,22 +3,22 @@ from django.db import models # Create your models here. class GameModel(models.Model): - finished = models.BooleanField(default = False) - started = models.BooleanField(default = False) - winner_id = models.IntegerField(default = -1) - - def create(self, players_id: [int]): - self.save() - for player_id in players_id: - GameMembersModel(game_id = self.pk, player_id = player_id).save() - return self.pk + finished = models.BooleanField(default = False) + started = models.BooleanField(default = False) + winner_id = models.IntegerField(default = -1) + + def create(self, players_id: [int]): + self.save() + for player_id in players_id: + GameMembersModel(game_id = self.pk, player_id = player_id).save() + return self.pk - def start(self): - self.started = True - - def get_players_id(self): - return [game_player.player_id for game_player in GameMembersModel.objects.filter(game_id = self.pk)] + def start(self): + self.started = True + + def get_players_id(self): + return [game_player.player_id for game_player in GameMembersModel.objects.filter(game_id = self.pk)] class GameMembersModel(models.Model): - game_id = models.IntegerField() - player_id = models.IntegerField() \ No newline at end of file + game_id = models.IntegerField() + player_id = models.IntegerField() \ No newline at end of file diff --git a/games/routing.py b/games/routing.py index eed3b1c..34f4c4d 100644 --- a/games/routing.py +++ b/games/routing.py @@ -2,5 +2,5 @@ from django.urls import re_path from . import consumers websocket_urlpatterns = [ - re_path(r'ws/games/(?P\d+)$', consumers.GameWebSocket.as_asgi()) + re_path(r'ws/games/(?P\d+)$', consumers.GameWebSocket.as_asgi()) ] diff --git a/games/views.py b/games/views.py index 21bdb50..2559264 100644 --- a/games/views.py +++ b/games/views.py @@ -8,20 +8,20 @@ from . import config class GameConfigView(APIView): - permission_classes = (permissions.AllowAny,) + permission_classes = (permissions.AllowAny,) - def get(self, request: HttpRequest): - config_data = { - "MAP_SIZE_X": config.MAP_SIZE_X, - "MAP_SIZE_Y": config.MAP_SIZE_Y, + def get(self, request: HttpRequest): + config_data = { + "MAP_SIZE_X": config.MAP_SIZE_X, + "MAP_SIZE_Y": config.MAP_SIZE_Y, - "WALL_RATIO": config.WALL_RATIO, + "WALL_RATIO": config.WALL_RATIO, - "PADDLE_SPEED_PER_SECOND_MAX": config.PADDLE_SPEED_PER_SECOND_MAX, - "PADDLE_RATIO": config.PADDLE_RATIO, + "PADDLE_SPEED_PER_SECOND_MAX": config.PADDLE_SPEED_PER_SECOND_MAX, + "PADDLE_RATIO": config.PADDLE_RATIO, - "BALL_SIZE": config.BALL_SIZE, - "BALL_SPEED_INC": config.BALL_SPEED_INC, - "BALL_SPEED_START": config.BALL_SPEED_START - } - return Response(config_data, status = status.HTTP_200_OK) \ No newline at end of file + "BALL_SIZE": config.BALL_SIZE, + "BALL_SPEED_INC": config.BALL_SPEED_INC, + "BALL_SPEED_START": config.BALL_SPEED_START + } + return Response(config_data, status = status.HTTP_200_OK) \ No newline at end of file diff --git a/matchmaking/consumers.py b/matchmaking/consumers.py index 819ca40..cb2041d 100644 --- a/matchmaking/consumers.py +++ b/matchmaking/consumers.py @@ -10,32 +10,32 @@ from .models import Waiter, WaitingRoom, WaitingRoomManager, normal class MatchMaking(WebsocketConsumer): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self.channel_name = "matchmaking" - self.group_name = "matchmaking" + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.channel_name = "matchmaking" + self.group_name = "matchmaking" - def connect(self): + def connect(self): - user: User = self.scope["user"] - if (user.is_anonymous or not user.is_authenticated): - return + user: User = self.scope["user"] + if (user.is_anonymous or not user.is_authenticated): + return - self.channel_layer.group_add(self.group_name, self.channel_name) + self.channel_layer.group_add(self.group_name, self.channel_name) - self.mode = int(self.scope['url_route']['kwargs']['mode']) - self.group_name = self.mode + self.mode = int(self.scope['url_route']['kwargs']['mode']) + self.group_name = self.mode - waiting_room: WaitingRoom = normal.get(self.mode) - waiting_room.append(Waiter(user.pk, self)) - waiting_room.broadcast(f"{len(waiting_room)} / {waiting_room.mode}") - if (len(waiting_room) == waiting_room.mode): - game_id: int = GameModel().create(waiting_room.get_users_id()) - waiting_room.broadcast("game_found", {"game_id": game_id}) - waiting_room.clear() + waiting_room: WaitingRoom = normal.get(self.mode) + waiting_room.append(Waiter(user.pk, self)) + waiting_room.broadcast(f"{len(waiting_room)} / {waiting_room.mode}") + if (len(waiting_room) == waiting_room.mode): + game_id: int = GameModel().create(waiting_room.get_users_id()) + waiting_room.broadcast("game_found", {"game_id": game_id}) + waiting_room.clear() - def disconnect(self, close_code): - waiting_room: WaitingRoom = normal.get(self.mode) - waiter: Waiter = waiting_room.get_member_by_socket(self) - if (waiter is not None): - waiting_room.remove(waiter, 1016) \ No newline at end of file + def disconnect(self, close_code): + waiting_room: WaitingRoom = normal.get(self.mode) + waiter: Waiter = waiting_room.get_member_by_socket(self) + if (waiter is not None): + waiting_room.remove(waiter, 1016) \ No newline at end of file diff --git a/matchmaking/models.py b/matchmaking/models.py index 8ce235d..2c6b3d6 100644 --- a/matchmaking/models.py +++ b/matchmaking/models.py @@ -9,31 +9,31 @@ from transcendence.abstract.AbstractRoomMember import AbstractRoomMember # Create your models here. class Waiter(AbstractRoomMember): - pass + pass class WaitingRoom(AbstractRoom): - - def __init__(self, room_manager,mode): - super().__init__(room_manager) - self.mode = mode + + def __init__(self, room_manager,mode): + super().__init__(room_manager) + self.mode = mode - def append(self, waiter: Waiter): - tmp: Waiter = self.get_member_by_user_id(waiter.user_id) - if (tmp is not None): - tmp.send("Connection close: Another connection open with the same user id.") - self.remove(tmp) - waiter.accept() - self._member_list.append(waiter) + def append(self, waiter: Waiter): + tmp: Waiter = self.get_member_by_user_id(waiter.user_id) + if (tmp is not None): + tmp.send("Connection close: Another connection open with the same user id.") + self.remove(tmp) + waiter.accept() + self._member_list.append(waiter) class WaitingRoomManager(AbstractRoomManager): - def get(self, mode: int): - for waiting_room in self._room_list: - waiting_room: WaitingRoom - if (waiting_room.mode == mode): - return waiting_room - tmp: WaitingRoom = WaitingRoom(self, mode) - super().append(tmp) - return tmp + def get(self, mode: int): + for waiting_room in self._room_list: + waiting_room: WaitingRoom + if (waiting_room.mode == mode): + return waiting_room + tmp: WaitingRoom = WaitingRoom(self, mode) + super().append(tmp) + return tmp normal: WaitingRoomManager = WaitingRoomManager() \ No newline at end of file diff --git a/matchmaking/routing.py b/matchmaking/routing.py index 417779b..22af33e 100644 --- a/matchmaking/routing.py +++ b/matchmaking/routing.py @@ -2,5 +2,5 @@ from django.urls import re_path from . import consumers websocket_urlpatterns = [ - re_path(r'ws/matchmaking/(?P\d+)$', consumers.MatchMaking.as_asgi()) + re_path(r'ws/matchmaking/(?P\d+)$', consumers.MatchMaking.as_asgi()) ] diff --git a/profiles/models.py b/profiles/models.py index aaff1ad..581ab0b 100644 --- a/profiles/models.py +++ b/profiles/models.py @@ -28,74 +28,74 @@ 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 = IntegerField(primary_key=False) - blocked = IntegerField(primary_key=False) + blocker = IntegerField(primary_key=False) + blocked = IntegerField(primary_key=False) - def __str__(self): - return "blocker_id: " + str(self.blocker) + ", blocked_id: " + str(self.blocked) + def __str__(self): + return "blocker_id: " + str(self.blocker) + ", blocked_id: " + str(self.blocked) class AskFriendModel(models.Model): - asker = IntegerField(primary_key=False) - asked = IntegerField(primary_key=False) + asker = IntegerField(primary_key=False) + asked = IntegerField(primary_key=False) - def getAsked(self, asker): - askeds = [] + def getAsked(self, asker): + askeds = [] - for ask in AskFriendModel.objects.filter(asker=asker): - askeds.append(ask.asked) + for ask in AskFriendModel.objects.filter(asker=asker): + askeds.append(ask.asked) - return askeds + return askeds - def getAsker(self, asked): - askers = [] + def getAsker(self, asked): + askers = [] - for ask in AskFriendModel.objects.filter(asked=asked): - askers.append(ask.asker) + for ask in AskFriendModel.objects.filter(asked=asked): + askers.append(ask.asker) - return askers + return askers - def deleteAsk(self, asker, asked): + def deleteAsk(self, asker, asked): - deleted = AskFriendModel.objects.filter(asker=asker, asked=asked) + deleted = AskFriendModel.objects.filter(asker=asker, asked=asked) - if (deleted.count() == 0 or not deleted): - return False + if (deleted.count() == 0 or not deleted): + return False - deleted.delete() - return True + deleted.delete() + return True class FriendModel(models.Model): - user_id1 = IntegerField(primary_key=False) - user_id2 = IntegerField(primary_key=False) + user_id1 = IntegerField(primary_key=False) + user_id2 = IntegerField(primary_key=False) - def getFriends(self, user_id): - friends = [] + 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_id1=user_id): + friends.append(friend.user_id2) - for friend in FriendModel.objects.filter(user_id2=user_id): - friends.append(friend.user_id1) + for friend in FriendModel.objects.filter(user_id2=user_id): + friends.append(friend.user_id1) - return friends + return friends - def isFriend(self, user_id1, user_id2): + def isFriend(self, user_id1, user_id2): - return user_id2 in self.getFriends(user_id1) + return user_id2 in self.getFriends(user_id1) - def deleteFriend(self, user_id1, user_id2): + 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 + 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 + second = FriendModel.objects.filter(user_id1=user_id2, user_id2=user_id1) + if (second.count() == 1): + second.delete() + return True - return False + return False diff --git a/profiles/urls.py b/profiles/urls.py index d2f5bb4..c7e9236 100644 --- a/profiles/urls.py +++ b/profiles/urls.py @@ -7,9 +7,9 @@ urlpatterns = [ path("settings", viewsets.MyProfileViewSet.as_view({'patch': 'partial_update'}), name="my_profile_page"), path("me", viewsets.MyProfileViewSet.as_view({'get': 'retrieve'}), name="my_profile_page"), path("", viewsets.ProfileViewSet.as_view({'get': 'list'}), name="profiles_list"), - path("block", views.BlocksView.as_view(), name="block_page"), - path("block/", views.BlockView.as_view(), name="block_page"), - path("friend", views.FriendsView.as_view(), name="friend_page"), + path("block", views.BlocksView.as_view(), name="block_page"), + path("block/", views.BlockView.as_view(), name="block_page"), + path("friend", views.FriendsView.as_view(), name="friend_page"), path("user/", viewsets.ProfileViewSet.as_view({'get': 'retrieve'}), name="profile_page"), path("id/", viewsets.ProfileViewSet.as_view({'get': 'retrieve_id'}), name="profile_page"), diff --git a/profiles/views.py b/profiles/views.py index 8c27128..406264c 100644 --- a/profiles/views.py +++ b/profiles/views.py @@ -7,74 +7,74 @@ from django.core import serializers from .models import BlockModel, FriendModel class BlockView(APIView): - permission_classes = (permissions.IsAuthenticated,) - authentication_classes = (SessionAuthentication,) + permission_classes = (permissions.IsAuthenticated,) + authentication_classes = (SessionAuthentication,) - def get(self, request, pk): - block = BlockModel.objects.filter(pk=pk) - if (block.exists()): - return Response(serializers.serialize("json", block), status=status.HTTP_200_OK) - else: - return Response("Not Found", status=status.HTTP_404_NOT_FOUND) + def get(self, request, pk): + block = BlockModel.objects.filter(pk=pk) + if (block.exists()): + return Response(serializers.serialize("json", block), status=status.HTTP_200_OK) + else: + return Response("Not Found", status=status.HTTP_404_NOT_FOUND) class BlocksView(APIView): - permission_classes = (permissions.IsAuthenticated,) - authentication_classes = (SessionAuthentication,) + permission_classes = (permissions.IsAuthenticated,) + authentication_classes = (SessionAuthentication,) - def get(self, request): - blocks = BlockModel.objects.filter(blocker=request.user.pk) - if (blocks): - return Response({"blockeds": serializers.serialize("json", BlockModel.objects.filter(blocker=request.user.pk)), "user_id": request.user.pk}, status=status.HTTP_200_OK) - return Response({}, status=status.HTTP_204_NO_CONTENT) + def get(self, request): + blocks = BlockModel.objects.filter(blocker=request.user.pk) + if (blocks): + return Response({"blockeds": serializers.serialize("json", BlockModel.objects.filter(blocker=request.user.pk)), "user_id": request.user.pk}, status=status.HTTP_200_OK) + return Response({}, status=status.HTTP_204_NO_CONTENT) - def post(self, request): - data: dict = request.data - users_id = request.data.get("users_id", None) + def post(self, request): + data: dict = request.data + users_id = request.data.get("users_id", None) - if (users_id == None): - return Response({"Error send None"}, status=status.HTTP_400_BAD_REQUEST) + if (users_id == None): + return Response({"Error send None"}, status=status.HTTP_400_BAD_REQUEST) - if (users_id[0] == None or users_id[1] == None): - return Response({"Error send blocker/ed None"}, status=status.HTTP_400_BAD_REQUEST) + if (users_id[0] == None or users_id[1] == None): + return Response({"Error send blocker/ed None"}, status=status.HTTP_400_BAD_REQUEST) - if (BlockModel.objects.filter(blocker=users_id[0], blocked=users_id[1])): - return Response({"Already Exist"}, status=status.HTTP_409_CONFLICT) + if (BlockModel.objects.filter(blocker=users_id[0], blocked=users_id[1])): + return Response({"Already Exist"}, status=status.HTTP_409_CONFLICT) - new_block = BlockModel() - new_block.blocker = users_id[0] - new_block.blocked = users_id[1] - new_block.save() + new_block = BlockModel() + new_block.blocker = users_id[0] + new_block.blocked = users_id[1] + new_block.save() - return Response({"block_id": new_block.pk}, status=status.HTTP_201_CREATED) + return Response({"block_id": new_block.pk}, status=status.HTTP_201_CREATED) - def delete(self, request): - data: dict = request.data - users_id = request.data.get("users_id", None) + def delete(self, request): + data: dict = request.data + users_id = request.data.get("users_id", None) - if (users_id == None): - return Response({"Error"}, status=status.HTTP_400_BAD_REQUEST) + if (users_id == None): + return Response({"Error"}, status=status.HTTP_400_BAD_REQUEST) - if (users_id[0] == None or users_id[1] == None): - return Response({"Error send blocker/ed None"}, status=status.HTTP_400_BAD_REQUEST) + if (users_id[0] == None or users_id[1] == None): + return Response({"Error send blocker/ed None"}, status=status.HTTP_400_BAD_REQUEST) - block = BlockModel.objects.filter(blocker=users_id[0], blocked=users_id[1]) + block = BlockModel.objects.filter(blocker=users_id[0], blocked=users_id[1]) - if (block.count() > 1): - return Response("Not normal >:[", status=status.HTTP_500_INTERNAL_SERVER_ERROR) - - if (not block): - return Response("Don't exist", status=status.HTTP_404_NOT_FOUND) + if (block.count() > 1): + return Response("Not normal >:[", status=status.HTTP_500_INTERNAL_SERVER_ERROR) + + if (not block): + return Response("Don't exist", status=status.HTTP_404_NOT_FOUND) - block.delete() - return Response("Deleted", status=status.HTTP_200_OK) + block.delete() + return Response("Deleted", status=status.HTTP_200_OK) class FriendsView(APIView): - permission_classes = (permissions.IsAuthenticated,) - authentication_classes = (SessionAuthentication,) + permission_classes = (permissions.IsAuthenticated,) + authentication_classes = (SessionAuthentication,) - def get(self, request): - 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) + def get(self, request): + 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) diff --git a/tournament/consumers.py b/tournament/consumers.py index ea2bb46..4198470 100644 --- a/tournament/consumers.py +++ b/tournament/consumers.py @@ -10,34 +10,34 @@ from .models import tournament_manager, TournamentMember, TournamentRoom, Tourna class TournamentWebConsumer(WebsocketConsumer): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self.channel_name = "tournament" - self.group_name = "tournament" + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.channel_name = "tournament" + self.group_name = "tournament" - def connect(self): + def connect(self): - self.user: User = self.scope["user"] - if (self.user.is_anonymous or not self.user.is_authenticated): - return + self.user: User = self.scope["user"] + if (self.user.is_anonymous or not self.user.is_authenticated): + return - self.channel_layer.group_add(self.group_name, self.channel_name) + self.channel_layer.group_add(self.group_name, self.channel_name) - self.tournament_id = int(self.scope['url_route']['kwargs']['tournament_id']) + self.tournament_id = int(self.scope['url_route']['kwargs']['tournament_id']) - self.room = tournament_manager.get(self.tournament_id) - self.member = TournamentMember(self.user.pk, self, self.room) + self.room = tournament_manager.get(self.tournament_id) + self.member = TournamentMember(self.user.pk, self, self.room) - if (self.room is None): - self.member.send("Tournament not found") - self.disconnect(1017) - - self.room.append(self.member) + if (self.room is None): + self.member.send("Tournament not found") + self.disconnect(1017) + + self.room.append(self.member) - def receive(self, text_data: str = None, bytes_data: bytes = None): - self.member.receive(text_data, bytes_data) + def receive(self, text_data: str = None, bytes_data: bytes = None): + self.member.receive(text_data, bytes_data) - def disconnect(self, close_code): - member = self.room.get_member_by_socket(self) - if (member is not None): - self.room.remove(self.member, close_code) \ No newline at end of file + def disconnect(self, close_code): + member = self.room.get_member_by_socket(self) + if (member is not None): + self.room.remove(self.member, close_code) \ No newline at end of file diff --git a/tournament/models.py b/tournament/models.py index 912ec62..f664e1e 100644 --- a/tournament/models.py +++ b/tournament/models.py @@ -13,142 +13,142 @@ from transcendence.abstract.AbstractRoomManager import AbstractRoomManager # Create your models here.tu class TournamentModel(models.Model): - name = models.CharField(max_length = 100) - nb_players = models.IntegerField() - nb_players_by_game = models.IntegerField() - level = models.IntegerField() - started = models.BooleanField(default = False) - finished = models.BooleanField(default = False) + name = models.CharField(max_length = 100) + nb_players = models.IntegerField() + nb_players_by_game = models.IntegerField() + level = models.IntegerField() + started = models.BooleanField(default = False) + finished = models.BooleanField(default = False) - def create_game(self, level, players_id): - game_id = GameModel().create(players_id = players_id) - TournamentGamesModel(game_id = game_id, tournament_id = self.pk, tournament_level = level).save() - return game_id - - def get_games_id_by_level(self, level): - tmp = TournamentGamesModel.objects.filter(tournament_id = self.pk, tournament_level = level) - return [instance.game_id for instance in tmp] + def create_game(self, level, players_id): + game_id = GameModel().create(players_id = players_id) + TournamentGamesModel(game_id = game_id, tournament_id = self.pk, tournament_level = level).save() + return game_id + + def get_games_id_by_level(self, level): + tmp = TournamentGamesModel.objects.filter(tournament_id = self.pk, tournament_level = level) + return [instance.game_id for instance in tmp] - def get_games_id(self): - return [tournament_game.game_id for tournament_game in TournamentGamesModel.objects.filter(tournament_id = self.pk)] - - def get_players_id(self): - return [model.participant_id for model in TournamentParticipantsModel.objects.filter(tournament_id=self.pk)] - - def is_a_participant(self, participant_id: int): - return TournamentParticipantsModel.objects.filter(participant_id = participant_id, tournament_id = self.pk).exists() + def get_games_id(self): + return [tournament_game.game_id for tournament_game in TournamentGamesModel.objects.filter(tournament_id = self.pk)] + + def get_players_id(self): + return [model.participant_id for model in TournamentParticipantsModel.objects.filter(tournament_id=self.pk)] + + def is_a_participant(self, participant_id: int): + return TournamentParticipantsModel.objects.filter(participant_id = participant_id, tournament_id = self.pk).exists() - def add_participants(self, participants_id: [int]): - for participant_id in participants_id: - TournamentParticipantsModel(tournament_id = self.pk, participant_id = participant_id).save() + def add_participants(self, participants_id: [int]): + for participant_id in participants_id: + TournamentParticipantsModel(tournament_id = self.pk, participant_id = participant_id).save() - def start(self, participants_id: [int]): - self.started = True - self.add_participants(participants_id) - games_id = [int] - for i in range(0, len(participants_id), self.nb_players_by_game): - game_id = self.create_game(0, participants_id[i : i + self.nb_players_by_game]) - games_id.append(game_id) - self.save() - return games_id + def start(self, participants_id: [int]): + self.started = True + self.add_participants(participants_id) + games_id = [int] + for i in range(0, len(participants_id), self.nb_players_by_game): + game_id = self.create_game(0, participants_id[i : i + self.nb_players_by_game]) + games_id.append(game_id) + self.save() + return games_id class TournamentParticipantsModel(models.Model): - tournament_id = models.IntegerField() - participant_id = models.IntegerField() + tournament_id = models.IntegerField() + participant_id = models.IntegerField() class TournamentGamesModel(models.Model): - tournament_id = models.IntegerField() - tournament_level = models.IntegerField() - game_id = models.IntegerField() + tournament_id = models.IntegerField() + tournament_level = models.IntegerField() + game_id = models.IntegerField() class TournamentMember(AbstractRoomMember): - def __init__(self, user_id: int, socket: WebsocketConsumer, room): - super().__init__(user_id, socket) - self.participate = False - self.room = room + def __init__(self, user_id: int, socket: WebsocketConsumer, room): + super().__init__(user_id, socket) + self.participate = False + self.room = room - def receive(self, text_data: str = None, byte_dates: bytes = None): - - if (text_data is None): - return + def receive(self, text_data: str = None, byte_dates: bytes = None): + + if (text_data is None): + return - data: dict = json.loads(text_data) + data: dict = json.loads(text_data) - if (data.get("participate") is not None): - self.room.update_participants(self) + if (data.get("participate") is not None): + self.room.update_participants(self) - def send_error_message(self, message: str): - self.send("error", {"error_message": message}) + def send_error_message(self, message: str): + self.send("error", {"error_message": message}) - def go_to(self, url: str): - self.send("go_to", {"url": url}) - - def send_participating(self): - self.send("is_participant", {"is_participant": self.participate}) + def go_to(self, url: str): + self.send("go_to", {"url": url}) + + def send_participating(self): + self.send("is_participant", {"is_participant": self.participate}) class TournamentRoom(AbstractRoom): - def __init__(self, room_manager, tournament_id: int): - super().__init__(room_manager) - self.tournament_id = tournament_id - self.tournament = TournamentModel.objects.get(pk = tournament_id) + def __init__(self, room_manager, tournament_id: int): + super().__init__(room_manager) + self.tournament_id = tournament_id + self.tournament = TournamentModel.objects.get(pk = tournament_id) - def start(self): - self.broadcast("tournament_start") - games_id = self.tournament.start(self.get_participants_id()) - for i, participant in enumerate(self.get_participants()): - participant: TournamentMember - participant.go_to(f"games/{games_id[i // self.tournament.nb_players_by_game]}") + def start(self): + self.broadcast("tournament_start") + games_id = self.tournament.start(self.get_participants_id()) + for i, participant in enumerate(self.get_participants()): + participant: TournamentMember + participant.go_to(f"games/{games_id[i // self.tournament.nb_players_by_game]}") - def update_participants(self, member: TournamentMember): - if (self.tournament.started): - member.send_error_message("Tournament already started") - return - member.participate = not member.participate - nb_participants = self.get_nb_participants() - self.broadcast("update_participants", {"nb_participants": nb_participants}) - member.send_participating() - if (nb_participants == self.tournament.nb_players): - self.start() + def update_participants(self, member: TournamentMember): + if (self.tournament.started): + member.send_error_message("Tournament already started") + return + member.participate = not member.participate + nb_participants = self.get_nb_participants() + self.broadcast("update_participants", {"nb_participants": nb_participants}) + member.send_participating() + if (nb_participants == self.tournament.nb_players): + self.start() - def get_nb_participants(self): - if (self.tournament.started): - return self.tournament.nb_players - nb_participants = 0 - for member in self._member_list: - member: TournamentMember - if (member.participate): - nb_participants += 1 - return nb_participants + def get_nb_participants(self): + if (self.tournament.started): + return self.tournament.nb_players + nb_participants = 0 + for member in self._member_list: + member: TournamentMember + if (member.participate): + nb_participants += 1 + return nb_participants - def get_participants(self): - return [member for member in self._member_list if member.participate] + def get_participants(self): + return [member for member in self._member_list if member.participate] - def get_participants_id(self): - return [member.user_id for member in self._member_list if member.participate] + def get_participants_id(self): + return [member.user_id for member in self._member_list if member.participate] - def append(self, member: TournamentMember): - super().append(member) - if self.tournament.started: - member.participate = self.tournament.is_a_participant(member.user_id) - member.send_participating() - member.send("nb_participants", {"nb_participants": self.get_nb_participants()}) + def append(self, member: TournamentMember): + super().append(member) + if self.tournament.started: + member.participate = self.tournament.is_a_participant(member.user_id) + member.send_participating() + member.send("nb_participants", {"nb_participants": self.get_nb_participants()}) class TournamentRoomManager(AbstractRoomManager): - def get(self, tournament_id: int): + def get(self, tournament_id: int): - for room in self._room_list: - if (room.tournament_id == tournament_id): - return room - - if (TournamentModel.objects.filter(pk = tournament_id).exists()): - room = TournamentRoom(self, tournament_id) - self.append(room) - return room - - return None + for room in self._room_list: + if (room.tournament_id == tournament_id): + return room + + if (TournamentModel.objects.filter(pk = tournament_id).exists()): + room = TournamentRoom(self, tournament_id) + self.append(room) + return room + + return None tournament_manager: TournamentRoomManager = TournamentRoomManager() \ No newline at end of file diff --git a/tournament/routing.py b/tournament/routing.py index 7271972..805d8a2 100644 --- a/tournament/routing.py +++ b/tournament/routing.py @@ -2,5 +2,5 @@ from django.urls import re_path from . import consumers websocket_urlpatterns = [ - re_path(r'ws/tournaments/(?P\d+)$', consumers.TournamentWebConsumer.as_asgi()) + re_path(r'ws/tournaments/(?P\d+)$', consumers.TournamentWebConsumer.as_asgi()) ] diff --git a/tournament/serializers.py b/tournament/serializers.py index bdfcfb3..6f29235 100644 --- a/tournament/serializers.py +++ b/tournament/serializers.py @@ -4,35 +4,35 @@ from games.serializers import GameSerializer class TournamentSerializer(serializers.ModelSerializer): - levels = serializers.SerializerMethodField(read_only=True, required=False) - level = serializers.ReadOnlyField() - started = serializers.ReadOnlyField() - finished = serializers.ReadOnlyField() - name = serializers.CharField(default="") + levels = serializers.SerializerMethodField(read_only=True, required=False) + level = serializers.ReadOnlyField() + started = serializers.ReadOnlyField() + finished = serializers.ReadOnlyField() + name = serializers.CharField(default="") - class Meta: - model = TournamentModel - fields = ["name", "nb_players", "nb_players_by_game", "level", "started", "finished", "levels", "id"] + class Meta: + model = TournamentModel + fields = ["name", "nb_players", "nb_players_by_game", "level", "started", "finished", "levels", "id"] - def get_levels(self, instance: TournamentModel): - levels: list[list[int]] = [] - for i in range(instance.level): - games_id: [int] = instance.get_games_id_by_level(i) - if (games_id == []): - break - levels.append(games_id) - return levels + def get_levels(self, instance: TournamentModel): + levels: list[list[int]] = [] + for i in range(instance.level): + games_id: [int] = instance.get_games_id_by_level(i) + if (games_id == []): + break + levels.append(games_id) + return levels - def validate_nb_players(self, value: int): - if (value < 2): - raise serializers.ValidationError("The numbers of players must be greather than 2.") - return value - def validate_nb_players_by_game(self, value: int): - if (value < 2): - raise serializers.ValidationError("The numbers of players by game must be greather than 2.") - nb_players: str = self.initial_data.get("nb_players") - if (nb_players is not None and nb_players.isnumeric()): - nb_players: int = int(nb_players) - if (value > nb_players): - raise serializers.ValidationError("The numbers of players by game must be smaller than the numbers of players.") - return value \ No newline at end of file + def validate_nb_players(self, value: int): + if (value < 2): + raise serializers.ValidationError("The numbers of players must be greather than 2.") + return value + def validate_nb_players_by_game(self, value: int): + if (value < 2): + raise serializers.ValidationError("The numbers of players by game must be greather than 2.") + nb_players: str = self.initial_data.get("nb_players") + if (nb_players is not None and nb_players.isnumeric()): + nb_players: int = int(nb_players) + if (value > nb_players): + raise serializers.ValidationError("The numbers of players by game must be smaller than the numbers of players.") + return value \ No newline at end of file diff --git a/tournament/test.py b/tournament/test.py index 3da31cb..077f4e4 100644 --- a/tournament/test.py +++ b/tournament/test.py @@ -9,36 +9,36 @@ import json import uuid class CreateTest(TestCase): - def setUp(self): - self.client = Client() + def setUp(self): + self.client = Client() - self.url = "/api/tournaments/" + self.url = "/api/tournaments/" - self.username = str(uuid.uuid4()) - self.password = str(uuid.uuid4()) + self.username = str(uuid.uuid4()) + self.password = str(uuid.uuid4()) - self.nb_players_by_game = 2 - self.nb_players = 8 + self.nb_players_by_game = 2 + self.nb_players = 8 - user: User = User.objects.create_user(username=self.username, password=self.password) - self.client.login(username=self.username, password=self.password) + user: User = User.objects.create_user(username=self.username, password=self.password) + self.client.login(username=self.username, password=self.password) - def test_normal(self): - response: HttpResponse = self.client.post(self.url, {"nb_players_by_game": self.nb_players_by_game, "nb_players": self.nb_players}) - response_data: dict = json.loads(response.content) - self.assertDictContainsSubset({"name": ""}, response_data) + def test_normal(self): + response: HttpResponse = self.client.post(self.url, {"nb_players_by_game": self.nb_players_by_game, "nb_players": self.nb_players}) + response_data: dict = json.loads(response.content) + self.assertDictContainsSubset({"name": ""}, response_data) - def test_too_small_nb_players_by_game(self): - response: HttpResponse = self.client.post(self.url, {"nb_players_by_game": 1, "nb_players": self.nb_players}) - response_data = json.loads(response.content) - self.assertDictEqual(response_data, {'nb_players_by_game': ['The numbers of players by game must be greather than 2.']}) - - def test_too_small_nb_players(self): - response: HttpResponse = self.client.post(self.url, {"nb_players_by_game": self.nb_players_by_game, "nb_players": 1}) - response_data = json.loads(response.content) - self.assertDictEqual(response_data, {'nb_players': ['The numbers of players must be greather than 2.'], 'nb_players_by_game': ['The numbers of players by game must be smaller than the numbers of players.']}) + def test_too_small_nb_players_by_game(self): + response: HttpResponse = self.client.post(self.url, {"nb_players_by_game": 1, "nb_players": self.nb_players}) + response_data = json.loads(response.content) + self.assertDictEqual(response_data, {'nb_players_by_game': ['The numbers of players by game must be greather than 2.']}) + + def test_too_small_nb_players(self): + response: HttpResponse = self.client.post(self.url, {"nb_players_by_game": self.nb_players_by_game, "nb_players": 1}) + response_data = json.loads(response.content) + self.assertDictEqual(response_data, {'nb_players': ['The numbers of players must be greather than 2.'], 'nb_players_by_game': ['The numbers of players by game must be smaller than the numbers of players.']}) - def test_nb_players_smaller_nb_players_by_game(self): - response: HttpResponse = self.client.post(self.url, {"nb_players_by_game": 5, "nb_players": 3}) - response_data = json.loads(response.content) - self.assertDictEqual(response_data, {'nb_players_by_game': ['The numbers of players by game must be smaller than the numbers of players.']}) \ No newline at end of file + def test_nb_players_smaller_nb_players_by_game(self): + response: HttpResponse = self.client.post(self.url, {"nb_players_by_game": 5, "nb_players": 3}) + response_data = json.loads(response.content) + self.assertDictEqual(response_data, {'nb_players_by_game': ['The numbers of players by game must be smaller than the numbers of players.']}) \ No newline at end of file diff --git a/tournament/viewset.py b/tournament/viewset.py index bc27f11..0ffd2cd 100644 --- a/tournament/viewset.py +++ b/tournament/viewset.py @@ -13,44 +13,44 @@ from .serializers import TournamentSerializer # Create your views here. class TournamentViewSet(viewsets.ModelViewSet): - queryset = TournamentModel.objects.all - serializer_class = TournamentSerializer - permission_classes = (permissions.IsAuthenticated,) - authentication_classes = (SessionAuthentication,) + queryset = TournamentModel.objects.all + serializer_class = TournamentSerializer + permission_classes = (permissions.IsAuthenticated,) + authentication_classes = (SessionAuthentication,) - def perform_create(self, serializer: TournamentSerializer): + def perform_create(self, serializer: TournamentSerializer): - nb_players = serializer.validated_data["nb_players"] - nb_players_by_game = serializer.validated_data["nb_players_by_game"] - level = 1 - number: int = nb_players - while (number != nb_players_by_game): - number = number // 2 + (number % 2) - level += 1 + nb_players = serializer.validated_data["nb_players"] + nb_players_by_game = serializer.validated_data["nb_players_by_game"] + level = 1 + number: int = nb_players + while (number != nb_players_by_game): + number = number // 2 + (number % 2) + level += 1 - tournament = serializer.save(level = level) - - return Response(self.serializer_class(tournament).data, status=status.HTTP_201_CREATED) - - def list(self, request: HttpRequest, state: str = ""): - query: QuerySet - match state: - case "started": - query = TournamentModel.objects.filter(started=True, finished=False) - case "finished": - query = TournamentModel.objects.filter(finished=True) - case "waiting": - query = TournamentModel.objects.filter(started=False, finished=False) - case _: - query = TournamentModel.objects.all() - serializer = TournamentSerializer(query, many=True) - return Response(serializer.data) + tournament = serializer.save(level = level) + + return Response(self.serializer_class(tournament).data, status=status.HTTP_201_CREATED) + + def list(self, request: HttpRequest, state: str = ""): + query: QuerySet + match state: + case "started": + query = TournamentModel.objects.filter(started=True, finished=False) + case "finished": + query = TournamentModel.objects.filter(finished=True) + case "waiting": + query = TournamentModel.objects.filter(started=False, finished=False) + case _: + query = TournamentModel.objects.all() + serializer = TournamentSerializer(query, many=True) + return Response(serializer.data) - def retrieve(self, request: HttpRequest, pk): + def retrieve(self, request: HttpRequest, pk): - if (not TournamentModel.objects.filter(pk=pk).exists()): - return Response({"detail": "Tournament not found."}, status=status.HTTP_404_NOT_FOUND) - - tournament = TournamentModel.objects.get(pk=pk) + if (not TournamentModel.objects.filter(pk=pk).exists()): + return Response({"detail": "Tournament not found."}, status=status.HTTP_404_NOT_FOUND) + + tournament = TournamentModel.objects.get(pk=pk) - return Response(self.serializer_class(tournament).data, status=status.HTTP_200_OK) \ No newline at end of file + return Response(self.serializer_class(tournament).data, status=status.HTTP_200_OK) \ No newline at end of file diff --git a/transcendence/abstract/AbstractRoom.py b/transcendence/abstract/AbstractRoom.py index 7c1c87f..ba0e414 100644 --- a/transcendence/abstract/AbstractRoom.py +++ b/transcendence/abstract/AbstractRoom.py @@ -3,49 +3,49 @@ from channels.generic.websocket import WebsocketConsumer from .AbstractRoomMember import AbstractRoomMember class AbstractRoom: - - def __init__(self, room_manager): - self._member_list: [AbstractRoomMember] = [] - self.room_manager = room_manager + + def __init__(self, room_manager): + self._member_list: [AbstractRoomMember] = [] + self.room_manager = room_manager - def broadcast(self, detail: str, data: dict = {}): - for member in self._member_list: - member: AbstractRoomMember - member.send(detail, data) - - def clear(self): - self._member_list.clear() + def broadcast(self, detail: str, data: dict = {}): + for member in self._member_list: + member: AbstractRoomMember + member.send(detail, data) + + def clear(self): + self._member_list.clear() - def get_member_by_socket(self, socket: WebsocketConsumer): - for member in self._member_list: - member: AbstractRoomMember - if (member.socket is socket): - return member - return None + def get_member_by_socket(self, socket: WebsocketConsumer): + for member in self._member_list: + member: AbstractRoomMember + if (member.socket is socket): + return member + return None - def get_member_by_user_id(self, user_id: int): - for member in self._member_list: - member: AbstractRoomMember - if (member.user_id == user_id): - return member - return None + def get_member_by_user_id(self, user_id: int): + for member in self._member_list: + member: AbstractRoomMember + if (member.user_id == user_id): + return member + return None - def append(self, member: AbstractRoomMember): - self._member_list.append(member) - member.accept() + def append(self, member: AbstractRoomMember): + self._member_list.append(member) + member.accept() - def remove(self, member: AbstractRoomMember, code: int = 1000): - self._member_list.remove(member) - member.disconnect(code) + def remove(self, member: AbstractRoomMember, code: int = 1000): + self._member_list.remove(member) + member.disconnect(code) - def empty(self): - for _ in self._member_list: - return False - return True + def empty(self): + for _ in self._member_list: + return False + return True - def get_users_id(self): - return [member.user_id for member in self._member_list] + def get_users_id(self): + return [member.user_id for member in self._member_list] - def __len__(self): - return len(self._member_list) + def __len__(self): + return len(self._member_list) diff --git a/transcendence/abstract/AbstractRoomManager.py b/transcendence/abstract/AbstractRoomManager.py index a4bf09a..88468f3 100644 --- a/transcendence/abstract/AbstractRoomManager.py +++ b/transcendence/abstract/AbstractRoomManager.py @@ -2,11 +2,11 @@ from .AbstractRoom import AbstractRoom class AbstractRoomManager: - def __init__(self): - self._room_list: [AbstractRoom] = [] + def __init__(self): + self._room_list: [AbstractRoom] = [] - def remove(self, room: AbstractRoom): - self._room_list.remove(room) + def remove(self, room: AbstractRoom): + self._room_list.remove(room) - def append(self, room: AbstractRoom): - self._room_list.append(room) + def append(self, room: AbstractRoom): + self._room_list.append(room) diff --git a/transcendence/abstract/AbstractRoomMember.py b/transcendence/abstract/AbstractRoomMember.py index 0a89b98..2dd161b 100644 --- a/transcendence/abstract/AbstractRoomMember.py +++ b/transcendence/abstract/AbstractRoomMember.py @@ -4,17 +4,17 @@ import json class AbstractRoomMember: - def __init__(self, user_id: int, socket: WebsocketConsumer): - self.user_id: int = user_id - self.socket: WebsocketConsumer = socket - - def send(self, detail: str, data: dict = {}): - raw_data: dict = {"detail": detail} - raw_data.update(data) - self.socket.send(text_data=json.dumps(raw_data)) + def __init__(self, user_id: int, socket: WebsocketConsumer): + self.user_id: int = user_id + self.socket: WebsocketConsumer = socket + + def send(self, detail: str, data: dict = {}): + raw_data: dict = {"detail": detail} + raw_data.update(data) + self.socket.send(text_data=json.dumps(raw_data)) - def accept(self): - self.socket.accept() + def accept(self): + self.socket.accept() - def disconnect(self, code: int = 1000): - self.socket.disconnect(code) \ No newline at end of file + def disconnect(self, code: int = 1000): + self.socket.disconnect(code) \ No newline at end of file diff --git a/transcendence/asgi.py b/transcendence/asgi.py index cb8ac86..8d907a4 100644 --- a/transcendence/asgi.py +++ b/transcendence/asgi.py @@ -22,13 +22,13 @@ os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'trancendence.settings') application = ProtocolTypeRouter({ 'http':get_asgi_application(), - 'websocket':AuthMiddlewareStack( - URLRouter( - chat.routing.websocket_urlpatterns + - matchmaking.routing.websocket_urlpatterns + - tournament.routing.websocket_urlpatterns + - games.routing.websocket_urlpatterns - ) - ) + 'websocket':AuthMiddlewareStack( + URLRouter( + chat.routing.websocket_urlpatterns + + matchmaking.routing.websocket_urlpatterns + + tournament.routing.websocket_urlpatterns + + games.routing.websocket_urlpatterns + ) + ) }) diff --git a/transcendence/settings.py b/transcendence/settings.py index 7e4fe90..44bdff8 100644 --- a/transcendence/settings.py +++ b/transcendence/settings.py @@ -41,8 +41,8 @@ CORS_ORIGIN_WHITELIST = ( # Application definition INSTALLED_APPS = [ - 'channels', - 'daphne', + 'channels', + 'daphne', 'tournament.apps.TournamentConfig', 'matchmaking.apps.MatchmakingConfig', @@ -65,9 +65,9 @@ INSTALLED_APPS = [ ASGI_APPLICATION = 'transcendence.asgi.application' CHANNEL_LAYERS = { - 'default' :{ - 'BACKEND':'channels.layers.InMemoryChannelLayer' - } + 'default' :{ + 'BACKEND':'channels.layers.InMemoryChannelLayer' + } } MIDDLEWARE = [