starnakin/42_ft_transcendence
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

the tabulations must die

Browse Source
This commit is contained in:
AdrienLSH 2024-02-08 12:47:10 +01:00
parent ce35db8b83
commit eb10175805
32 changed files with 1070 additions and 1070 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
accounts/serializers/login.py
View File

@ -4,9 +4,9 @@ from django.core.exceptions import ValidationError
class LoginSerializer(Serializer): class LoginSerializer(Serializer):
username = CharField() username = CharField()
password = CharField() password = CharField()
def get_user(self, data): def get_user(self, data):
user = authenticate(username=data['username'], password=data['password']) user = authenticate(username=data['username'], password=data['password'])
return user return user

24
accounts/views/delete.py
View File

@ -6,16 +6,16 @@ from django.http import HttpRequest
from rest_framework.authentication import SessionAuthentication from rest_framework.authentication import SessionAuthentication
class DeleteView(APIView): class DeleteView(APIView):
permission_classes = (permissions.IsAuthenticated,) permission_classes = (permissions.IsAuthenticated,)
authentication_classes = (SessionAuthentication,) authentication_classes = (SessionAuthentication,)
def delete(self, request: HttpRequest): def delete(self, request: HttpRequest):
data: dict = request.data data: dict = request.data
password: str = data["password"] password: str = data["password"]
if (password is None): if (password is None):
return Response({"password": ["This field may not be blank."]}) return Response({"password": ["This field may not be blank."]})
if (request.user.check_password(password) == False): if (request.user.check_password(password) == False):
return Response({"password": ["Password wrong."]}) return Response({"password": ["Password wrong."]})
request.user.delete() request.user.delete()
logout(request) logout(request)
return Response("user deleted", status=status.HTTP_200_OK) return Response("user deleted", status=status.HTTP_200_OK)

8
accounts/views/logged.py
View File

@ -9,8 +9,8 @@ from ..serializers.login import LoginSerializer
class LoggedView(APIView): class LoggedView(APIView):
permission_classes = (permissions.AllowAny,) permission_classes = (permissions.AllowAny,)
authentication_classes = (SessionAuthentication,) authentication_classes = (SessionAuthentication,)
def get(self, request: HttpRequest): def get(self, request: HttpRequest):
return Response(status = (status.HTTP_200_OK if request.user.is_authenticated else status.HTTP_400_BAD_REQUEST)) return Response(status = (status.HTTP_200_OK if request.user.is_authenticated else status.HTTP_400_BAD_REQUEST))

22
accounts/views/login.py
View File

@ -10,15 +10,15 @@ from ..serializers.login import LoginSerializer
class LoginView(APIView): class LoginView(APIView):
permission_classes = (permissions.AllowAny,) permission_classes = (permissions.AllowAny,)
authentication_classes = (SessionAuthentication,) authentication_classes = (SessionAuthentication,)
def post(self, request: HttpRequest): def post(self, request: HttpRequest):
data = request.data data = request.data
serializer = LoginSerializer(data=data) serializer = LoginSerializer(data=data)
serializer.is_valid(raise_exception=True) serializer.is_valid(raise_exception=True)
user = serializer.get_user(data) user = serializer.get_user(data)
if user is None: if user is None:
return Response({'login': [_('Invalid username or password.')]}, status.HTTP_401_UNAUTHORIZED) return Response({'login': [_('Invalid username or password.')]}, status.HTTP_401_UNAUTHORIZED)
login(request, user) login(request, user)
return Response({'id': user.pk}, status=status.HTTP_200_OK) return Response({'id': user.pk}, status=status.HTTP_200_OK)

10
accounts/views/logout.py
View File

@ -6,8 +6,8 @@ from django.http import HttpRequest
from rest_framework.authentication import SessionAuthentication from rest_framework.authentication import SessionAuthentication
class LogoutView(APIView): class LogoutView(APIView):
permission_classes = (permissions.IsAuthenticated,) permission_classes = (permissions.IsAuthenticated,)
authentication_classes = (SessionAuthentication,) authentication_classes = (SessionAuthentication,)
def get(self, request: HttpRequest): def get(self, request: HttpRequest):
logout(request) logout(request)
return Response("user unlogged", status=status.HTTP_200_OK) return Response("user unlogged", status=status.HTTP_200_OK)

20
accounts/views/register.py
View File

@ -6,13 +6,13 @@ from django.http import HttpRequest
from django.contrib.auth import login from django.contrib.auth import login
class RegisterView(APIView): class RegisterView(APIView):
permission_classes = (permissions.AllowAny,) permission_classes = (permissions.AllowAny,)
def post(self, request: HttpRequest): def post(self, request: HttpRequest):
data = request.data data = request.data
serializer = RegisterSerialiser(data=data) serializer = RegisterSerialiser(data=data)
if serializer.is_valid(raise_exception=True): if serializer.is_valid(raise_exception=True):
user = serializer.create(data) user = serializer.create(data)
if user: if user:
login(request, user) login(request, user)
return Response("user created", status=status.HTTP_201_CREATED) return Response("user created", status=status.HTTP_201_CREATED)
return Response(status=status.HTTP_400_BAD_REQUEST) return Response(status=status.HTTP_400_BAD_REQUEST)

366
chat/consumersChat.py
View File

@ -8,244 +8,244 @@ import json
class ChatConsumer(WebsocketConsumer): class ChatConsumer(WebsocketConsumer):
def connect(self): def connect(self):
user = self.scope["user"] user = self.scope["user"]
if (user.is_anonymous or not user.is_authenticated): if (user.is_anonymous or not user.is_authenticated):
return 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: if ChatMemberModel.objects.filter(member_id=user.pk, channel_id=int(channel_id)).count() != 1:
return return
if (self.channel_layer == None): if (self.channel_layer == None):
return 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)( async_to_sync(self.channel_layer.group_add)(
self.room_group_name, self.room_group_name,
self.channel_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: if text_data == None:
return return
user = self.scope["user"] user = self.scope["user"]
if (user.is_anonymous or not user.is_authenticated): if (user.is_anonymous or not user.is_authenticated):
return return
text_data_json: dict = json.loads(text_data) text_data_json: dict = json.loads(text_data)
message = text_data_json.get('message') message = text_data_json.get('message')
if (message is None): if (message is None):
return return
receivers_id = text_data_json.get('receivers_id') receivers_id = text_data_json.get('receivers_id')
if (receivers_id is None): if (receivers_id is None):
return 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: if ChatMemberModel.objects.filter(member_id = user.pk, channel_id = channel_id).count() != 1:
return return
if (self.channel_layer == None): if (self.channel_layer == None):
return return
message_time: int = int(time.time() * 1000) message_time: int = int(time.time() * 1000)
if (len(receivers_id) == 1 and if (len(receivers_id) == 1 and
BlockModel.objects.filter(blocker=user.pk, blocked=receivers_id[0]) or BlockModel.objects.filter(blocker=user.pk, blocked=receivers_id[0]) or
BlockModel.objects.filter(blocker=receivers_id[0], blocked=user.pk) BlockModel.objects.filter(blocker=receivers_id[0], blocked=user.pk)
): ):
return return
async_to_sync(self.channel_layer.group_send)( async_to_sync(self.channel_layer.group_send)(
self.room_group_name, 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( new_message = ChatMessageModel(
channel_id = channel_id, channel_id = channel_id,
author_id = user.pk, author_id = user.pk,
content = message, content = message,
time = message_time time = message_time
).save() ).save()
def chat_message(self, event): def chat_message(self, event):
user = self.scope["user"] user = self.scope["user"]
if (user.is_anonymous or not user.is_authenticated): if (user.is_anonymous or not user.is_authenticated):
return 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: if ChatMemberModel.objects.filter(member_id=user.pk, channel_id=channel_id).count() != 1:
return return
self.send(text_data=json.dumps({ 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'], 'time': event['time'],
})) }))
class ChatNoticeConsumer(WebsocketConsumer): class ChatNoticeConsumer(WebsocketConsumer):
def connect(self): def connect(self):
user = self.scope["user"] user = self.scope["user"]
#if (user.is_anonymous or not user.is_authenticated): #if (user.is_anonymous or not user.is_authenticated):
#return #return
if (self.channel_layer == None): if (self.channel_layer == None):
return return
self.room_group_name = f'chatNotice{user.pk}' self.room_group_name = f'chatNotice{user.pk}'
if (not hasattr(self.channel_layer, "users_channels")): if (not hasattr(self.channel_layer, "users_channels")):
self.channel_layer.users_channels = {} self.channel_layer.users_channels = {}
self.channel_layer.users_channels[user.pk] = self.channel_name self.channel_layer.users_channels[user.pk] = self.channel_name
if (not hasattr(self.channel_layer, "invite")): if (not hasattr(self.channel_layer, "invite")):
self.channel_layer.invite = {} self.channel_layer.invite = {}
self.channel_layer.invite[user.pk] = []; self.channel_layer.invite[user.pk] = [];
async_to_sync(self.channel_layer.group_add)( async_to_sync(self.channel_layer.group_add)(
self.room_group_name, self.room_group_name,
self.channel_name self.channel_name
) )
self.accept() self.accept()
message_time: int = int(time.time() * 1000) message_time: int = int(time.time() * 1000)
targets = list(self.channel_layer.users_channels.keys()) targets = list(self.channel_layer.users_channels.keys())
for target in targets: for target in targets:
channel = self.channel_layer.users_channels.get(target) channel = self.channel_layer.users_channels.get(target)
if (channel == None or target == user.pk): if (channel == None or target == user.pk):
continue continue
async_to_sync(self.channel_layer.send)(channel, { async_to_sync(self.channel_layer.send)(channel, {
'type':"online_users", 'type':"online_users",
'author_id':user.pk, 'author_id':user.pk,
'time':message_time, 'time':message_time,
}) })
def disconnect(self, code): def disconnect(self, code):
user = self.scope["user"] user = self.scope["user"]
if (user.is_anonymous or not user.is_authenticated): if (user.is_anonymous or not user.is_authenticated):
return 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()) targets = list(self.channel_layer.users_channels.keys())
for target in targets: for target in targets:
channel = self.channel_layer.users_channels.get(target) channel = self.channel_layer.users_channels.get(target)
if (channel == None or target == user.pk): if (channel == None or target == user.pk):
continue continue
async_to_sync(self.channel_layer.send)(channel, { async_to_sync(self.channel_layer.send)(channel, {
'type':"online_users", 'type':"online_users",
'author_id':user.pk, 'author_id':user.pk,
'time':message_time, '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: if text_data == None:
return return
user = self.scope["user"] user = self.scope["user"]
#if (user.is_anonymous or not user.is_authenticated): #if (user.is_anonymous or not user.is_authenticated):
#return #return
text_data_json = json.loads(text_data) text_data_json = json.loads(text_data)
type_notice = text_data_json.get('type') type_notice = text_data_json.get('type')
targets : list = text_data_json.get('targets') targets : list = text_data_json.get('targets')
content : dict = text_data_json.get('content') content : dict = text_data_json.get('content')
if (type_notice == None or targets == None): if (type_notice == None or targets == None):
return return
if (self.channel_layer == None): if (self.channel_layer == None):
return return
message_time: int = int(time.time() * 1000) message_time: int = int(time.time() * 1000)
status = 200; status = 200;
#print("receive" + str(user.pk)) #print("receive" + str(user.pk))
if targets == "all": if targets == "all":
targets = list(self.channel_layer.users_channels.keys()) targets = list(self.channel_layer.users_channels.keys())
for target in targets: for target in targets:
channel = self.channel_layer.users_channels.get(target) channel = self.channel_layer.users_channels.get(target)
if (channel == None or target == user.pk): if (channel == None or target == user.pk):
if (channel == None): if (channel == None):
status = 404 status = 404
continue continue
async_to_sync(self.channel_layer.send)(channel, { async_to_sync(self.channel_layer.send)(channel, {
'type':type_notice, 'type':type_notice,
'author_id':user.pk, 'author_id':user.pk,
'content':content, 'content':content,
'time':message_time, 'time':message_time,
'status': 200, 'status': 200,
}) })
async_to_sync(self.channel_layer.send)(self.channel_layer.users_channels.get(user.pk), { async_to_sync(self.channel_layer.send)(self.channel_layer.users_channels.get(user.pk), {
'type':type_notice, 'type':type_notice,
'author_id':user.pk, 'author_id':user.pk,
'content':"notice return", 'content':"notice return",
'time':message_time, 'time':message_time,
'status':status, 'status':status,
}) })
def invite(self, event): def invite(self, event):
user = self.scope["user"] user = self.scope["user"]
if (user.is_anonymous or not user.is_authenticated): if (user.is_anonymous or not user.is_authenticated):
return return
if (self.channel_layer.invite[event["author_id"]].get(user.pk)): if (self.channel_layer.invite[event["author_id"]].get(user.pk)):
return return
self.channel_layer.invite[event["author_id"]].append(user.pl) self.channel_layer.invite[event["author_id"]].append(user.pl)
self.send(text_data=json.dumps({ self.send(text_data=json.dumps({
'type':event['type'], 'type':event['type'],
'author_id':event['author_id'], 'author_id':event['author_id'],
'content':event['content'], 'content':event['content'],
'time': event['time'], 'time': event['time'],
'status':event['status'], 'status':event['status'],
})) }))
def online_users(self, event): def online_users(self, event):
user = self.scope["user"] user = self.scope["user"]
#if (user.is_anonymous or not user.is_authenticated): #if (user.is_anonymous or not user.is_authenticated):
#return #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({ self.send(text_data=json.dumps({
'type':event['type'], 'type':event['type'],
'author_id':event['author_id'], 'author_id':event['author_id'],
'content':event['content'], 'content':event['content'],
'time': event['time'], 'time': event['time'],
'status':event['status'], 'status':event['status'],
})) }))

636
chat/consumersNotice.py
View File

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

36
chat/models.py
View File

@ -5,28 +5,28 @@ from django.contrib import admin
# Create your models here. # Create your models here.
class ChatChannelModel(models.Model): class ChatChannelModel(models.Model):
def create(self, users_id: [int]): def create(self, users_id: [int]):
self.save() self.save()
for user_id in users_id: for user_id in users_id:
ChatMemberModel(channel_id = self.pk, member_id = user_id).save() ChatMemberModel(channel_id = self.pk, member_id = user_id).save()
return self.pk return self.pk
def get_members_id(self): def get_members_id(self):
return [member_channel.member_id for member_channel in ChatMemberModel.objects.filter(channel_id = self.pk)] return [member_channel.member_id for member_channel in ChatMemberModel.objects.filter(channel_id = self.pk)]
class ChatMemberModel(models.Model): class ChatMemberModel(models.Model):
member_id = IntegerField(primary_key=False) member_id = IntegerField(primary_key=False)
channel_id = IntegerField(primary_key=False) channel_id = IntegerField(primary_key=False)
def __str__(self): def __str__(self):
return "member_id: " + str(self.member_id) + ", channel_id: " + str(self.channel_id) return "member_id: " + str(self.member_id) + ", channel_id: " + str(self.channel_id)
class ChatMessageModel(models.Model): class ChatMessageModel(models.Model):
channel_id = IntegerField(primary_key=False) channel_id = IntegerField(primary_key=False)
author_id = IntegerField(primary_key=False) author_id = IntegerField(primary_key=False)
content = models.CharField(max_length=255) content = models.CharField(max_length=255)
time = IntegerField(primary_key=False) time = IntegerField(primary_key=False)
def __str__(self): def __str__(self):
return "author_id: " + str(self.author_id) + ", channel_id: " + str(self.channel_id) + ", content: " + self.content return "author_id: " + str(self.author_id) + ", channel_id: " + str(self.channel_id) + ", content: " + self.content

4
chat/routing.py
View File

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

32
chat/tests.py
View File

@ -6,25 +6,25 @@ from django.contrib.auth.models import User
# Create your tests here. # Create your tests here.
class ChatTest(TestCase): class ChatTest(TestCase):
def setUp(self): def setUp(self):
self.client = Client() self.client = Client()
self.username='bozo1' self.username='bozo1'
self.password='password' 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): def test_create_chat(self):
self.client.login(username=self.username, password=self.password) 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: HttpResponse = self.client.post(self.url + str(self.user.pk), {"members_id": [self.user.pk, self.dest.pk]})
response_dict: dict = eval(response.content) response_dict: dict = eval(response.content)
self.assertDictEqual(response_dict, {}) self.assertDictEqual(response_dict, {})
def test_create_chat_unlogged(self): 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: HttpResponse = self.client.post(self.url + str(self.user.pk), {"members_id": [self.user.pk, self.dest.pk]})
response_dict: dict = eval(response.content) response_dict: dict = eval(response.content)
self.assertDictEqual(response_dict, {'detail': 'Authentication credentials were not provided.'}) self.assertDictEqual(response_dict, {'detail': 'Authentication credentials were not provided.'})

50
chat/views.py
View File

@ -14,35 +14,35 @@ from .serializers import ChatChannelSerializer, ChatMessageSerializer
class ChannelView(APIView): class ChannelView(APIView):
queryset = ChatChannelModel.objects queryset = ChatChannelModel.objects
serializer_class = ChatChannelSerializer serializer_class = ChatChannelSerializer
permission_classes = (permissions.IsAuthenticated,) permission_classes = (permissions.IsAuthenticated,)
authentication_classes = (SessionAuthentication,) authentication_classes = (SessionAuthentication,)
def post(self, request): def post(self, request):
serializer = self.serializer_class(data = request.data) serializer = self.serializer_class(data = request.data)
serializer.is_valid(raise_exception=True) serializer.is_valid(raise_exception=True)
data: dict = serializer.validated_data data: dict = serializer.validated_data
members_id = data.get("members_id") members_id = data.get("members_id")
if members_id == None: if members_id == None:
return Response({"detail": "members_id is None."}, status = status.HTTP_400_BAD_REQUEST) return Response({"detail": "members_id is None."}, status = status.HTTP_400_BAD_REQUEST)
if self.request.user.pk not in members_id: 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) 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]): for member_channel in ChatMemberModel.objects.filter(member_id = members_id[0]):
channel_id: int = member_channel.channel_id channel_id: int = member_channel.channel_id
if not ChatChannelModel.objects.filter(pk = channel_id).exists(): if not ChatChannelModel.objects.filter(pk = channel_id).exists():
continue continue
channel: ChatChannelModel = ChatChannelModel.objects.get(pk = channel_id) channel: ChatChannelModel = ChatChannelModel.objects.get(pk = channel_id)
if set(channel.get_members_id()) == set(members_id): if set(channel.get_members_id()) == set(members_id):
messages = ChatMessageModel.objects.filter(channel_id = channel_id).order_by("time") messages = ChatMessageModel.objects.filter(channel_id = channel_id).order_by("time")
messages = serializers.serialize("json", messages) messages = serializers.serialize("json", messages)
return Response({'channel_id': channel_id, 'messages': messages}, status=status.HTTP_200_OK) return Response({'channel_id': channel_id, 'messages': messages}, status=status.HTTP_200_OK)
new_channel_id = ChatChannelModel().create(members_id) new_channel_id = ChatChannelModel().create(members_id)
return Response({'channel_id': new_channel_id}, status=status.HTTP_201_CREATED) return Response({'channel_id': new_channel_id}, status=status.HTTP_201_CREATED)

32
games/models.py
View File

@ -3,22 +3,22 @@ from django.db import models
# Create your models here. # Create your models here.
class GameModel(models.Model): class GameModel(models.Model):
finished = models.BooleanField(default = False) finished = models.BooleanField(default = False)
started = models.BooleanField(default = False) started = models.BooleanField(default = False)
winner_id = models.IntegerField(default = -1) winner_id = models.IntegerField(default = -1)
def create(self, players_id: [int]): def create(self, players_id: [int]):
self.save() self.save()
for player_id in players_id: for player_id in players_id:
GameMembersModel(game_id = self.pk, player_id = player_id).save() GameMembersModel(game_id = self.pk, player_id = player_id).save()
return self.pk return self.pk
def start(self): def start(self):
self.started = True self.started = True
def get_players_id(self): def get_players_id(self):
return [game_player.player_id for game_player in GameMembersModel.objects.filter(game_id = self.pk)] return [game_player.player_id for game_player in GameMembersModel.objects.filter(game_id = self.pk)]
class GameMembersModel(models.Model): class GameMembersModel(models.Model):
game_id = models.IntegerField() game_id = models.IntegerField()
player_id = models.IntegerField() player_id = models.IntegerField()

2
games/routing.py
View File

@ -2,5 +2,5 @@ from django.urls import re_path
from . import consumers from . import consumers
websocket_urlpatterns = [ websocket_urlpatterns = [
re_path(r'ws/games/(?P<game_id>\d+)$', consumers.GameWebSocket.as_asgi()) re_path(r'ws/games/(?P<game_id>\d+)$', consumers.GameWebSocket.as_asgi())
] ]

26
games/views.py
View File

@ -8,20 +8,20 @@ from . import config
class GameConfigView(APIView): class GameConfigView(APIView):
permission_classes = (permissions.AllowAny,) permission_classes = (permissions.AllowAny,)
def get(self, request: HttpRequest): def get(self, request: HttpRequest):
config_data = { config_data = {
"MAP_SIZE_X": config.MAP_SIZE_X, "MAP_SIZE_X": config.MAP_SIZE_X,
"MAP_SIZE_Y": config.MAP_SIZE_Y, "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_SPEED_PER_SECOND_MAX": config.PADDLE_SPEED_PER_SECOND_MAX,
"PADDLE_RATIO": config.PADDLE_RATIO, "PADDLE_RATIO": config.PADDLE_RATIO,
"BALL_SIZE": config.BALL_SIZE, "BALL_SIZE": config.BALL_SIZE,
"BALL_SPEED_INC": config.BALL_SPEED_INC, "BALL_SPEED_INC": config.BALL_SPEED_INC,
"BALL_SPEED_START": config.BALL_SPEED_START "BALL_SPEED_START": config.BALL_SPEED_START
} }
return Response(config_data, status = status.HTTP_200_OK) return Response(config_data, status = status.HTTP_200_OK)

46
matchmaking/consumers.py
View File

@ -10,32 +10,32 @@ from .models import Waiter, WaitingRoom, WaitingRoomManager, normal
class MatchMaking(WebsocketConsumer): class MatchMaking(WebsocketConsumer):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs) super().__init__(*args, **kwargs)
self.channel_name = "matchmaking" self.channel_name = "matchmaking"
self.group_name = "matchmaking" self.group_name = "matchmaking"
def connect(self): def connect(self):
user: User = self.scope["user"] user: User = self.scope["user"]
if (user.is_anonymous or not user.is_authenticated): if (user.is_anonymous or not user.is_authenticated):
return 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.mode = int(self.scope['url_route']['kwargs']['mode'])
self.group_name = self.mode self.group_name = self.mode
waiting_room: WaitingRoom = normal.get(self.mode) waiting_room: WaitingRoom = normal.get(self.mode)
waiting_room.append(Waiter(user.pk, self)) waiting_room.append(Waiter(user.pk, self))
waiting_room.broadcast(f"{len(waiting_room)} / {waiting_room.mode}") waiting_room.broadcast(f"{len(waiting_room)} / {waiting_room.mode}")
if (len(waiting_room) == waiting_room.mode): if (len(waiting_room) == waiting_room.mode):
game_id: int = GameModel().create(waiting_room.get_users_id()) game_id: int = GameModel().create(waiting_room.get_users_id())
waiting_room.broadcast("game_found", {"game_id": game_id}) waiting_room.broadcast("game_found", {"game_id": game_id})
waiting_room.clear() waiting_room.clear()
def disconnect(self, close_code): def disconnect(self, close_code):
waiting_room: WaitingRoom = normal.get(self.mode) waiting_room: WaitingRoom = normal.get(self.mode)
waiter: Waiter = waiting_room.get_member_by_socket(self) waiter: Waiter = waiting_room.get_member_by_socket(self)
if (waiter is not None): if (waiter is not None):
waiting_room.remove(waiter, 1016) waiting_room.remove(waiter, 1016)

40
matchmaking/models.py
View File

@ -9,31 +9,31 @@ from transcendence.abstract.AbstractRoomMember import AbstractRoomMember
# Create your models here. # Create your models here.
class Waiter(AbstractRoomMember): class Waiter(AbstractRoomMember):
pass pass
class WaitingRoom(AbstractRoom): class WaitingRoom(AbstractRoom):
def __init__(self, room_manager,mode): def __init__(self, room_manager,mode):
super().__init__(room_manager) super().__init__(room_manager)
self.mode = mode self.mode = mode
def append(self, waiter: Waiter): def append(self, waiter: Waiter):
tmp: Waiter = self.get_member_by_user_id(waiter.user_id) tmp: Waiter = self.get_member_by_user_id(waiter.user_id)
if (tmp is not None): if (tmp is not None):
tmp.send("Connection close: Another connection open with the same user id.") tmp.send("Connection close: Another connection open with the same user id.")
self.remove(tmp) self.remove(tmp)
waiter.accept() waiter.accept()
self._member_list.append(waiter) self._member_list.append(waiter)
class WaitingRoomManager(AbstractRoomManager): class WaitingRoomManager(AbstractRoomManager):
def get(self, mode: int): def get(self, mode: int):
for waiting_room in self._room_list: for waiting_room in self._room_list:
waiting_room: WaitingRoom waiting_room: WaitingRoom
if (waiting_room.mode == mode): if (waiting_room.mode == mode):
return waiting_room return waiting_room
tmp: WaitingRoom = WaitingRoom(self, mode) tmp: WaitingRoom = WaitingRoom(self, mode)
super().append(tmp) super().append(tmp)
return tmp return tmp
normal: WaitingRoomManager = WaitingRoomManager() normal: WaitingRoomManager = WaitingRoomManager()

2
matchmaking/routing.py
View File

@ -2,5 +2,5 @@ from django.urls import re_path
from . import consumers from . import consumers
websocket_urlpatterns = [ websocket_urlpatterns = [
re_path(r'ws/matchmaking/(?P<mode>\d+)$', consumers.MatchMaking.as_asgi()) re_path(r'ws/matchmaking/(?P<mode>\d+)$', consumers.MatchMaking.as_asgi())
] ]

88
profiles/models.py
View File

@ -28,74 +28,74 @@ def on_user_created(sender, instance, created, **kwargs):
if created: if created:
profile: ProfileModel = ProfileModel.objects.create(pk = instance.pk, user = instance) profile: ProfileModel = ProfileModel.objects.create(pk = instance.pk, user = instance)
profile.save() profile.save()
class BlockModel(models.Model): class BlockModel(models.Model):
blocker = IntegerField(primary_key=False) blocker = IntegerField(primary_key=False)
blocked = IntegerField(primary_key=False) blocked = IntegerField(primary_key=False)
def __str__(self): def __str__(self):
return "blocker_id: " + str(self.blocker) + ", blocked_id: " + str(self.blocked) return "blocker_id: " + str(self.blocker) + ", blocked_id: " + str(self.blocked)
class AskFriendModel(models.Model): class AskFriendModel(models.Model):
asker = IntegerField(primary_key=False) asker = IntegerField(primary_key=False)
asked = IntegerField(primary_key=False) asked = IntegerField(primary_key=False)
def getAsked(self, asker): def getAsked(self, asker):
askeds = [] askeds = []
for ask in AskFriendModel.objects.filter(asker=asker): for ask in AskFriendModel.objects.filter(asker=asker):
askeds.append(ask.asked) askeds.append(ask.asked)
return askeds return askeds
def getAsker(self, asked): def getAsker(self, asked):
askers = [] askers = []
for ask in AskFriendModel.objects.filter(asked=asked): for ask in AskFriendModel.objects.filter(asked=asked):
askers.append(ask.asker) 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): if (deleted.count() == 0 or not deleted):
return False return False
deleted.delete() deleted.delete()
return True return True
class FriendModel(models.Model): class FriendModel(models.Model):
user_id1 = IntegerField(primary_key=False) user_id1 = IntegerField(primary_key=False)
user_id2 = IntegerField(primary_key=False) user_id2 = IntegerField(primary_key=False)
def getFriends(self, user_id): def getFriends(self, user_id):
friends = [] friends = []
for friend in FriendModel.objects.filter(user_id1=user_id): for friend in FriendModel.objects.filter(user_id1=user_id):
friends.append(friend.user_id2) friends.append(friend.user_id2)
for friend in FriendModel.objects.filter(user_id2=user_id): for friend in FriendModel.objects.filter(user_id2=user_id):
friends.append(friend.user_id1) 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) first = FriendModel.objects.filter(user_id1=user_id1, user_id2=user_id2)
if (first.count() == 1): if (first.count() == 1):
first.delete() first.delete()
return True return True
second = FriendModel.objects.filter(user_id1=user_id2, user_id2=user_id1) second = FriendModel.objects.filter(user_id1=user_id2, user_id2=user_id1)
if (second.count() == 1): if (second.count() == 1):
second.delete() second.delete()
return True return True
return False return False

6
profiles/urls.py
View File

@ -7,9 +7,9 @@ urlpatterns = [
path("settings", viewsets.MyProfileViewSet.as_view({'patch': 'partial_update'}), name="my_profile_page"), 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("me", viewsets.MyProfileViewSet.as_view({'get': 'retrieve'}), name="my_profile_page"),
path("", viewsets.ProfileViewSet.as_view({'get': 'list'}), name="profiles_list"), path("", viewsets.ProfileViewSet.as_view({'get': 'list'}), name="profiles_list"),
path("block", views.BlocksView.as_view(), name="block_page"), path("block", views.BlocksView.as_view(), name="block_page"),
path("block/<int:pk>", views.BlockView.as_view(), name="block_page"), path("block/<int:pk>", views.BlockView.as_view(), name="block_page"),
path("friend", views.FriendsView.as_view(), name="friend_page"), path("friend", views.FriendsView.as_view(), name="friend_page"),
path("user/<str:username>", viewsets.ProfileViewSet.as_view({'get': 'retrieve'}), name="profile_page"), path("user/<str:username>", viewsets.ProfileViewSet.as_view({'get': 'retrieve'}), name="profile_page"),
path("id/<int:pk>", viewsets.ProfileViewSet.as_view({'get': 'retrieve_id'}), name="profile_page"), path("id/<int:pk>", viewsets.ProfileViewSet.as_view({'get': 'retrieve_id'}), name="profile_page"),

102
profiles/views.py
View File

@ -7,74 +7,74 @@ from django.core import serializers
from .models import BlockModel, FriendModel from .models import BlockModel, FriendModel
class BlockView(APIView): class BlockView(APIView):
permission_classes = (permissions.IsAuthenticated,) permission_classes = (permissions.IsAuthenticated,)
authentication_classes = (SessionAuthentication,) authentication_classes = (SessionAuthentication,)
def get(self, request, pk): def get(self, request, pk):
block = BlockModel.objects.filter(pk=pk) block = BlockModel.objects.filter(pk=pk)
if (block.exists()): if (block.exists()):
return Response(serializers.serialize("json", block), status=status.HTTP_200_OK) return Response(serializers.serialize("json", block), status=status.HTTP_200_OK)
else: else:
return Response("Not Found", status=status.HTTP_404_NOT_FOUND) return Response("Not Found", status=status.HTTP_404_NOT_FOUND)
class BlocksView(APIView): class BlocksView(APIView):
permission_classes = (permissions.IsAuthenticated,) permission_classes = (permissions.IsAuthenticated,)
authentication_classes = (SessionAuthentication,) authentication_classes = (SessionAuthentication,)
def get(self, request): def get(self, request):
blocks = BlockModel.objects.filter(blocker=request.user.pk) blocks = BlockModel.objects.filter(blocker=request.user.pk)
if (blocks): 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({"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) return Response({}, status=status.HTTP_204_NO_CONTENT)
def post(self, request): def post(self, request):
data: dict = request.data data: dict = request.data
users_id = request.data.get("users_id", None) users_id = request.data.get("users_id", None)
if (users_id == None): if (users_id == None):
return Response({"Error send None"}, status=status.HTTP_400_BAD_REQUEST) return Response({"Error send None"}, status=status.HTTP_400_BAD_REQUEST)
if (users_id[0] == None or users_id[1] == None): if (users_id[0] == None or users_id[1] == None):
return Response({"Error send blocker/ed None"}, status=status.HTTP_400_BAD_REQUEST) 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])): if (BlockModel.objects.filter(blocker=users_id[0], blocked=users_id[1])):
return Response({"Already Exist"}, status=status.HTTP_409_CONFLICT) return Response({"Already Exist"}, status=status.HTTP_409_CONFLICT)
new_block = BlockModel() new_block = BlockModel()
new_block.blocker = users_id[0] new_block.blocker = users_id[0]
new_block.blocked = users_id[1] new_block.blocked = users_id[1]
new_block.save() 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): def delete(self, request):
data: dict = request.data data: dict = request.data
users_id = request.data.get("users_id", None) users_id = request.data.get("users_id", None)
if (users_id == None): if (users_id == None):
return Response({"Error"}, status=status.HTTP_400_BAD_REQUEST) return Response({"Error"}, status=status.HTTP_400_BAD_REQUEST)
if (users_id[0] == None or users_id[1] == None): if (users_id[0] == None or users_id[1] == None):
return Response({"Error send blocker/ed None"}, status=status.HTTP_400_BAD_REQUEST) 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): if (block.count() > 1):
return Response("Not normal >:[", status=status.HTTP_500_INTERNAL_SERVER_ERROR) return Response("Not normal >:[", status=status.HTTP_500_INTERNAL_SERVER_ERROR)
if (not block): if (not block):
return Response("Don't exist", status=status.HTTP_404_NOT_FOUND) return Response("Don't exist", status=status.HTTP_404_NOT_FOUND)
block.delete() block.delete()
return Response("Deleted", status=status.HTTP_200_OK) return Response("Deleted", status=status.HTTP_200_OK)
class FriendsView(APIView): class FriendsView(APIView):
permission_classes = (permissions.IsAuthenticated,) permission_classes = (permissions.IsAuthenticated,)
authentication_classes = (SessionAuthentication,) authentication_classes = (SessionAuthentication,)
def get(self, request): def get(self, request):
friends = FriendModel().getFriends(request.user.pk) friends = FriendModel().getFriends(request.user.pk)
if (friends): if (friends):
return Response({"friends": friends, "user_id": request.user.pk}, status=status.HTTP_200_OK) return Response({"friends": friends, "user_id": request.user.pk}, status=status.HTTP_200_OK)
return Response({}, status=status.HTTP_204_NO_CONTENT) return Response({}, status=status.HTTP_204_NO_CONTENT)

46
tournament/consumers.py
View File

@ -10,34 +10,34 @@ from .models import tournament_manager, TournamentMember, TournamentRoom, Tourna
class TournamentWebConsumer(WebsocketConsumer): class TournamentWebConsumer(WebsocketConsumer):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs) super().__init__(*args, **kwargs)
self.channel_name = "tournament" self.channel_name = "tournament"
self.group_name = "tournament" self.group_name = "tournament"
def connect(self): def connect(self):
self.user: User = self.scope["user"] self.user: User = self.scope["user"]
if (self.user.is_anonymous or not self.user.is_authenticated): if (self.user.is_anonymous or not self.user.is_authenticated):
return 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.room = tournament_manager.get(self.tournament_id)
self.member = TournamentMember(self.user.pk, self, self.room) self.member = TournamentMember(self.user.pk, self, self.room)
if (self.room is None): if (self.room is None):
self.member.send("Tournament not found") self.member.send("Tournament not found")
self.disconnect(1017) self.disconnect(1017)
self.room.append(self.member) self.room.append(self.member)
def receive(self, text_data: str = None, bytes_data: bytes = None): def receive(self, text_data: str = None, bytes_data: bytes = None):
self.member.receive(text_data, bytes_data) self.member.receive(text_data, bytes_data)
def disconnect(self, close_code): def disconnect(self, close_code):
member = self.room.get_member_by_socket(self) member = self.room.get_member_by_socket(self)
if (member is not None): if (member is not None):
self.room.remove(self.member, close_code) self.room.remove(self.member, close_code)

214
tournament/models.py
View File

@ -13,142 +13,142 @@ from transcendence.abstract.AbstractRoomManager import AbstractRoomManager
# Create your models here.tu # Create your models here.tu
class TournamentModel(models.Model): class TournamentModel(models.Model):
name = models.CharField(max_length = 100) name = models.CharField(max_length = 100)
nb_players = models.IntegerField() nb_players = models.IntegerField()
nb_players_by_game = models.IntegerField() nb_players_by_game = models.IntegerField()
level = models.IntegerField() level = models.IntegerField()
started = models.BooleanField(default = False) started = models.BooleanField(default = False)
finished = models.BooleanField(default = False) finished = models.BooleanField(default = False)
def create_game(self, level, players_id): def create_game(self, level, players_id):
game_id = GameModel().create(players_id = players_id) game_id = GameModel().create(players_id = players_id)
TournamentGamesModel(game_id = game_id, tournament_id = self.pk, tournament_level = level).save() TournamentGamesModel(game_id = game_id, tournament_id = self.pk, tournament_level = level).save()
return game_id return game_id
def get_games_id_by_level(self, level): def get_games_id_by_level(self, level):
tmp = TournamentGamesModel.objects.filter(tournament_id = self.pk, tournament_level = level) tmp = TournamentGamesModel.objects.filter(tournament_id = self.pk, tournament_level = level)
return [instance.game_id for instance in tmp] return [instance.game_id for instance in tmp]
def get_games_id(self): def get_games_id(self):
return [tournament_game.game_id for tournament_game in TournamentGamesModel.objects.filter(tournament_id = self.pk)] return [tournament_game.game_id for tournament_game in TournamentGamesModel.objects.filter(tournament_id = self.pk)]
def get_players_id(self): def get_players_id(self):
return [model.participant_id for model in TournamentParticipantsModel.objects.filter(tournament_id=self.pk)] return [model.participant_id for model in TournamentParticipantsModel.objects.filter(tournament_id=self.pk)]
def is_a_participant(self, participant_id: int): def is_a_participant(self, participant_id: int):
return TournamentParticipantsModel.objects.filter(participant_id = participant_id, tournament_id = self.pk).exists() return TournamentParticipantsModel.objects.filter(participant_id = participant_id, tournament_id = self.pk).exists()
def add_participants(self, participants_id: [int]): def add_participants(self, participants_id: [int]):
for participant_id in participants_id: for participant_id in participants_id:
TournamentParticipantsModel(tournament_id = self.pk, participant_id = participant_id).save() TournamentParticipantsModel(tournament_id = self.pk, participant_id = participant_id).save()
def start(self, participants_id: [int]): def start(self, participants_id: [int]):
self.started = True self.started = True
self.add_participants(participants_id) self.add_participants(participants_id)
games_id = [int] games_id = [int]
for i in range(0, len(participants_id), self.nb_players_by_game): 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]) game_id = self.create_game(0, participants_id[i : i + self.nb_players_by_game])
games_id.append(game_id) games_id.append(game_id)
self.save() self.save()
return games_id return games_id
class TournamentParticipantsModel(models.Model): class TournamentParticipantsModel(models.Model):
tournament_id = models.IntegerField() tournament_id = models.IntegerField()
participant_id = models.IntegerField() participant_id = models.IntegerField()
class TournamentGamesModel(models.Model): class TournamentGamesModel(models.Model):
tournament_id = models.IntegerField() tournament_id = models.IntegerField()
tournament_level = models.IntegerField() tournament_level = models.IntegerField()
game_id = models.IntegerField() game_id = models.IntegerField()
class TournamentMember(AbstractRoomMember): class TournamentMember(AbstractRoomMember):
def __init__(self, user_id: int, socket: WebsocketConsumer, room): def __init__(self, user_id: int, socket: WebsocketConsumer, room):
super().__init__(user_id, socket) super().__init__(user_id, socket)
self.participate = False self.participate = False
self.room = room self.room = room
def receive(self, text_data: str = None, byte_dates: bytes = None): def receive(self, text_data: str = None, byte_dates: bytes = None):
if (text_data is None): if (text_data is None):
return return
data: dict = json.loads(text_data) data: dict = json.loads(text_data)
if (data.get("participate") is not None): if (data.get("participate") is not None):
self.room.update_participants(self) self.room.update_participants(self)
def send_error_message(self, message: str): def send_error_message(self, message: str):
self.send("error", {"error_message": message}) self.send("error", {"error_message": message})
def go_to(self, url: str): def go_to(self, url: str):
self.send("go_to", {"url": url}) self.send("go_to", {"url": url})
def send_participating(self): def send_participating(self):
self.send("is_participant", {"is_participant": self.participate}) self.send("is_participant", {"is_participant": self.participate})
class TournamentRoom(AbstractRoom): class TournamentRoom(AbstractRoom):
def __init__(self, room_manager, tournament_id: int): def __init__(self, room_manager, tournament_id: int):
super().__init__(room_manager) super().__init__(room_manager)
self.tournament_id = tournament_id self.tournament_id = tournament_id
self.tournament = TournamentModel.objects.get(pk = tournament_id) self.tournament = TournamentModel.objects.get(pk = tournament_id)
def start(self): def start(self):
self.broadcast("tournament_start") self.broadcast("tournament_start")
games_id = self.tournament.start(self.get_participants_id()) games_id = self.tournament.start(self.get_participants_id())
for i, participant in enumerate(self.get_participants()): for i, participant in enumerate(self.get_participants()):
participant: TournamentMember participant: TournamentMember
participant.go_to(f"games/{games_id[i // self.tournament.nb_players_by_game]}") participant.go_to(f"games/{games_id[i // self.tournament.nb_players_by_game]}")
def update_participants(self, member: TournamentMember): def update_participants(self, member: TournamentMember):
if (self.tournament.started): if (self.tournament.started):
member.send_error_message("Tournament already started") member.send_error_message("Tournament already started")
return return
member.participate = not member.participate member.participate = not member.participate
nb_participants = self.get_nb_participants() nb_participants = self.get_nb_participants()
self.broadcast("update_participants", {"nb_participants": nb_participants}) self.broadcast("update_participants", {"nb_participants": nb_participants})
member.send_participating() member.send_participating()
if (nb_participants == self.tournament.nb_players): if (nb_participants == self.tournament.nb_players):
self.start() self.start()
def get_nb_participants(self): def get_nb_participants(self):
if (self.tournament.started): if (self.tournament.started):
return self.tournament.nb_players return self.tournament.nb_players
nb_participants = 0 nb_participants = 0
for member in self._member_list: for member in self._member_list:
member: TournamentMember member: TournamentMember
if (member.participate): if (member.participate):
nb_participants += 1 nb_participants += 1
return nb_participants return nb_participants
def get_participants(self): def get_participants(self):
return [member for member in self._member_list if member.participate] return [member for member in self._member_list if member.participate]
def get_participants_id(self): def get_participants_id(self):
return [member.user_id for member in self._member_list if member.participate] return [member.user_id for member in self._member_list if member.participate]
def append(self, member: TournamentMember): def append(self, member: TournamentMember):
super().append(member) super().append(member)
if self.tournament.started: if self.tournament.started:
member.participate = self.tournament.is_a_participant(member.user_id) member.participate = self.tournament.is_a_participant(member.user_id)
member.send_participating() member.send_participating()
member.send("nb_participants", {"nb_participants": self.get_nb_participants()}) member.send("nb_participants", {"nb_participants": self.get_nb_participants()})
class TournamentRoomManager(AbstractRoomManager): class TournamentRoomManager(AbstractRoomManager):
def get(self, tournament_id: int): def get(self, tournament_id: int):
for room in self._room_list: for room in self._room_list:
if (room.tournament_id == tournament_id): if (room.tournament_id == tournament_id):
return room return room
if (TournamentModel.objects.filter(pk = tournament_id).exists()): if (TournamentModel.objects.filter(pk = tournament_id).exists()):
room = TournamentRoom(self, tournament_id) room = TournamentRoom(self, tournament_id)
self.append(room) self.append(room)
return room return room
return None return None
tournament_manager: TournamentRoomManager = TournamentRoomManager() tournament_manager: TournamentRoomManager = TournamentRoomManager()

2
tournament/routing.py
View File

@ -2,5 +2,5 @@ from django.urls import re_path
from . import consumers from . import consumers
websocket_urlpatterns = [ websocket_urlpatterns = [
re_path(r'ws/tournaments/(?P<tournament_id>\d+)$', consumers.TournamentWebConsumer.as_asgi()) re_path(r'ws/tournaments/(?P<tournament_id>\d+)$', consumers.TournamentWebConsumer.as_asgi())
] ]

58
tournament/serializers.py
View File

@ -4,35 +4,35 @@ from games.serializers import GameSerializer
class TournamentSerializer(serializers.ModelSerializer): class TournamentSerializer(serializers.ModelSerializer):
levels = serializers.SerializerMethodField(read_only=True, required=False) levels = serializers.SerializerMethodField(read_only=True, required=False)
level = serializers.ReadOnlyField() level = serializers.ReadOnlyField()
started = serializers.ReadOnlyField() started = serializers.ReadOnlyField()
finished = serializers.ReadOnlyField() finished = serializers.ReadOnlyField()
name = serializers.CharField(default="") name = serializers.CharField(default="")
class Meta: class Meta:
model = TournamentModel model = TournamentModel
fields = ["name", "nb_players", "nb_players_by_game", "level", "started", "finished", "levels", "id"] fields = ["name", "nb_players", "nb_players_by_game", "level", "started", "finished", "levels", "id"]
def get_levels(self, instance: TournamentModel): def get_levels(self, instance: TournamentModel):
levels: list[list[int]] = [] levels: list[list[int]] = []
for i in range(instance.level): for i in range(instance.level):
games_id: [int] = instance.get_games_id_by_level(i) games_id: [int] = instance.get_games_id_by_level(i)
if (games_id == []): if (games_id == []):
break break
levels.append(games_id) levels.append(games_id)
return levels return levels
def validate_nb_players(self, value: int): def validate_nb_players(self, value: int):
if (value < 2): if (value < 2):
raise serializers.ValidationError("The numbers of players must be greather than 2.") raise serializers.ValidationError("The numbers of players must be greather than 2.")
return value return value
def validate_nb_players_by_game(self, value: int): def validate_nb_players_by_game(self, value: int):
if (value < 2): if (value < 2):
raise serializers.ValidationError("The numbers of players by game must be greather than 2.") raise serializers.ValidationError("The numbers of players by game must be greather than 2.")
nb_players: str = self.initial_data.get("nb_players") nb_players: str = self.initial_data.get("nb_players")
if (nb_players is not None and nb_players.isnumeric()): if (nb_players is not None and nb_players.isnumeric()):
nb_players: int = int(nb_players) nb_players: int = int(nb_players)
if (value > nb_players): if (value > nb_players):
raise serializers.ValidationError("The numbers of players by game must be smaller than the numbers of players.") raise serializers.ValidationError("The numbers of players by game must be smaller than the numbers of players.")
return value return value

52
tournament/test.py
View File

@ -9,36 +9,36 @@ import json
import uuid import uuid
class CreateTest(TestCase): class CreateTest(TestCase):
def setUp(self): def setUp(self):
self.client = Client() self.client = Client()
self.url = "/api/tournaments/" self.url = "/api/tournaments/"
self.username = str(uuid.uuid4()) self.username = str(uuid.uuid4())
self.password = str(uuid.uuid4()) self.password = str(uuid.uuid4())
self.nb_players_by_game = 2 self.nb_players_by_game = 2
self.nb_players = 8 self.nb_players = 8
user: User = User.objects.create_user(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) self.client.login(username=self.username, password=self.password)
def test_normal(self): 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: 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) response_data: dict = json.loads(response.content)
self.assertDictContainsSubset({"name": ""}, response_data) self.assertDictContainsSubset({"name": ""}, response_data)
def test_too_small_nb_players_by_game(self): 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: HttpResponse = self.client.post(self.url, {"nb_players_by_game": 1, "nb_players": self.nb_players})
response_data = json.loads(response.content) 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.']}) 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): 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: HttpResponse = self.client.post(self.url, {"nb_players_by_game": self.nb_players_by_game, "nb_players": 1})
response_data = json.loads(response.content) 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.']}) 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): 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: HttpResponse = self.client.post(self.url, {"nb_players_by_game": 5, "nb_players": 3})
response_data = json.loads(response.content) 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.']}) self.assertDictEqual(response_data, {'nb_players_by_game': ['The numbers of players by game must be smaller than the numbers of players.']})

70
tournament/viewset.py
View File

@ -13,44 +13,44 @@ from .serializers import TournamentSerializer
# Create your views here. # Create your views here.
class TournamentViewSet(viewsets.ModelViewSet): class TournamentViewSet(viewsets.ModelViewSet):
queryset = TournamentModel.objects.all queryset = TournamentModel.objects.all
serializer_class = TournamentSerializer serializer_class = TournamentSerializer
permission_classes = (permissions.IsAuthenticated,) permission_classes = (permissions.IsAuthenticated,)
authentication_classes = (SessionAuthentication,) authentication_classes = (SessionAuthentication,)
def perform_create(self, serializer: TournamentSerializer): def perform_create(self, serializer: TournamentSerializer):
nb_players = serializer.validated_data["nb_players"] nb_players = serializer.validated_data["nb_players"]
nb_players_by_game = serializer.validated_data["nb_players_by_game"] nb_players_by_game = serializer.validated_data["nb_players_by_game"]
level = 1 level = 1
number: int = nb_players number: int = nb_players
while (number != nb_players_by_game): while (number != nb_players_by_game):
number = number // 2 + (number % 2) number = number // 2 + (number % 2)
level += 1 level += 1
tournament = serializer.save(level = level) tournament = serializer.save(level = level)
return Response(self.serializer_class(tournament).data, status=status.HTTP_201_CREATED) return Response(self.serializer_class(tournament).data, status=status.HTTP_201_CREATED)
def list(self, request: HttpRequest, state: str = ""): def list(self, request: HttpRequest, state: str = ""):
query: QuerySet query: QuerySet
match state: match state:
case "started": case "started":
query = TournamentModel.objects.filter(started=True, finished=False) query = TournamentModel.objects.filter(started=True, finished=False)
case "finished": case "finished":
query = TournamentModel.objects.filter(finished=True) query = TournamentModel.objects.filter(finished=True)
case "waiting": case "waiting":
query = TournamentModel.objects.filter(started=False, finished=False) query = TournamentModel.objects.filter(started=False, finished=False)
case _: case _:
query = TournamentModel.objects.all() query = TournamentModel.objects.all()
serializer = TournamentSerializer(query, many=True) serializer = TournamentSerializer(query, many=True)
return Response(serializer.data) return Response(serializer.data)
def retrieve(self, request: HttpRequest, pk): def retrieve(self, request: HttpRequest, pk):
if (not TournamentModel.objects.filter(pk=pk).exists()): if (not TournamentModel.objects.filter(pk=pk).exists()):
return Response({"detail": "Tournament not found."}, status=status.HTTP_404_NOT_FOUND) return Response({"detail": "Tournament not found."}, status=status.HTTP_404_NOT_FOUND)
tournament = TournamentModel.objects.get(pk=pk) tournament = TournamentModel.objects.get(pk=pk)
return Response(self.serializer_class(tournament).data, status=status.HTTP_200_OK) return Response(self.serializer_class(tournament).data, status=status.HTTP_200_OK)

74
transcendence/abstract/AbstractRoom.py
View File

@ -3,49 +3,49 @@ from channels.generic.websocket import WebsocketConsumer
from .AbstractRoomMember import AbstractRoomMember from .AbstractRoomMember import AbstractRoomMember
class AbstractRoom: class AbstractRoom:
def __init__(self, room_manager): def __init__(self, room_manager):
self._member_list: [AbstractRoomMember] = [] self._member_list: [AbstractRoomMember] = []
self.room_manager = room_manager self.room_manager = room_manager
def broadcast(self, detail: str, data: dict = {}): def broadcast(self, detail: str, data: dict = {}):
for member in self._member_list: for member in self._member_list:
member: AbstractRoomMember member: AbstractRoomMember
member.send(detail, data) member.send(detail, data)
def clear(self): def clear(self):
self._member_list.clear() self._member_list.clear()
def get_member_by_socket(self, socket: WebsocketConsumer): def get_member_by_socket(self, socket: WebsocketConsumer):
for member in self._member_list: for member in self._member_list:
member: AbstractRoomMember member: AbstractRoomMember
if (member.socket is socket): if (member.socket is socket):
return member return member
return None return None
def get_member_by_user_id(self, user_id: int): def get_member_by_user_id(self, user_id: int):
for member in self._member_list: for member in self._member_list:
member: AbstractRoomMember member: AbstractRoomMember
if (member.user_id == user_id): if (member.user_id == user_id):
return member return member
return None return None
def append(self, member: AbstractRoomMember): def append(self, member: AbstractRoomMember):
self._member_list.append(member) self._member_list.append(member)
member.accept() member.accept()
def remove(self, member: AbstractRoomMember, code: int = 1000): def remove(self, member: AbstractRoomMember, code: int = 1000):
self._member_list.remove(member) self._member_list.remove(member)
member.disconnect(code) member.disconnect(code)
def empty(self): def empty(self):
for _ in self._member_list: for _ in self._member_list:
return False return False
return True return True
def get_users_id(self): def get_users_id(self):
return [member.user_id for member in self._member_list] return [member.user_id for member in self._member_list]
def __len__(self): def __len__(self):
return len(self._member_list) return len(self._member_list)

12
transcendence/abstract/AbstractRoomManager.py
View File

@ -2,11 +2,11 @@ from .AbstractRoom import AbstractRoom
class AbstractRoomManager: class AbstractRoomManager:
def __init__(self): def __init__(self):
self._room_list: [AbstractRoom] = [] self._room_list: [AbstractRoom] = []
def remove(self, room: AbstractRoom): def remove(self, room: AbstractRoom):
self._room_list.remove(room) self._room_list.remove(room)
def append(self, room: AbstractRoom): def append(self, room: AbstractRoom):
self._room_list.append(room) self._room_list.append(room)

24
transcendence/abstract/AbstractRoomMember.py
View File

@ -4,17 +4,17 @@ import json
class AbstractRoomMember: class AbstractRoomMember:
def __init__(self, user_id: int, socket: WebsocketConsumer): def __init__(self, user_id: int, socket: WebsocketConsumer):
self.user_id: int = user_id self.user_id: int = user_id
self.socket: WebsocketConsumer = socket self.socket: WebsocketConsumer = socket
def send(self, detail: str, data: dict = {}): def send(self, detail: str, data: dict = {}):
raw_data: dict = {"detail": detail} raw_data: dict = {"detail": detail}
raw_data.update(data) raw_data.update(data)
self.socket.send(text_data=json.dumps(raw_data)) self.socket.send(text_data=json.dumps(raw_data))
def accept(self): def accept(self):
self.socket.accept() self.socket.accept()
def disconnect(self, code: int = 1000): def disconnect(self, code: int = 1000):
self.socket.disconnect(code) self.socket.disconnect(code)

16
transcendence/asgi.py
View File

@ -22,13 +22,13 @@ os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'trancendence.settings')
application = ProtocolTypeRouter({ application = ProtocolTypeRouter({
'http':get_asgi_application(), 'http':get_asgi_application(),
'websocket':AuthMiddlewareStack( 'websocket':AuthMiddlewareStack(
URLRouter( URLRouter(
chat.routing.websocket_urlpatterns + chat.routing.websocket_urlpatterns +
matchmaking.routing.websocket_urlpatterns + matchmaking.routing.websocket_urlpatterns +
tournament.routing.websocket_urlpatterns + tournament.routing.websocket_urlpatterns +
games.routing.websocket_urlpatterns games.routing.websocket_urlpatterns
) )
) )
}) })

10
transcendence/settings.py
View File

@ -41,8 +41,8 @@ CORS_ORIGIN_WHITELIST = (
# Application definition # Application definition
INSTALLED_APPS = [ INSTALLED_APPS = [
'channels', 'channels',
'daphne', 'daphne',
'tournament.apps.TournamentConfig', 'tournament.apps.TournamentConfig',
'matchmaking.apps.MatchmakingConfig', 'matchmaking.apps.MatchmakingConfig',
@ -65,9 +65,9 @@ INSTALLED_APPS = [
ASGI_APPLICATION = 'transcendence.asgi.application' ASGI_APPLICATION = 'transcendence.asgi.application'
CHANNEL_LAYERS = { CHANNEL_LAYERS = {
'default' :{ 'default' :{
'BACKEND':'channels.layers.InMemoryChannelLayer' 'BACKEND':'channels.layers.InMemoryChannelLayer'
} }
} }
MIDDLEWARE = [ MIDDLEWARE = [