Generateurv2/backend/api/room/consumers.py

250 lines
12 KiB
Python
Raw Normal View History

2022-05-18 10:15:54 +02:00
# chat/consumers.py
import json
from uuid import uuid4
from channels.generic.websocket import AsyncWebsocketConsumer
from channels.db import database_sync_to_async
from .models import Room
class RoomConsumer(AsyncWebsocketConsumer):
async def connect(self):
self.room_id = self.scope['url_route']['kwargs']['room_id']
self.waiter = None
self.clientId = str(uuid4())
self.waiter = False
self.waiter_code = None
self.user = None
try:
self.room = await self.get_room()
print('Connected')
await self.accept()
await self.send(json.dumps({'type': 'connect', "clientId": self.clientId}))
except:
print('closed')
await self.close()
async def receive(self, text_data):
text_data_json = json.loads(text_data)
type = text_data_json['data']['type']
print(text_data_json)
if type == "login":
participants = await self.get_participants()
nick = text_data_json['data']['nick']
if nick in list(map(lambda p: p['nick'], participants)):
print('Nooope', nick, nick in list(
map(lambda p: p['nick'], participants)))
await self.send(json.dumps({'type': 'loginResponse', "error": "USER_INPUT", "description": "Pseudo déjà utilisé"}))
else:
if self.room.private == True:
waiter = await self.add_waiter_db(nick)
if waiter != None:
self.waiter = True
self.waiter_code = waiter['code']
await self.send(json.dumps({'type': "waitingRoom", "nick": nick, 'id_code': self.room_id}))
await self.channel_layer.group_add(f'waiter__{waiter["code"]}', self.channel_name)
await self.channel_layer.group_send(f'owner__{self.room_id}', {"type": "add_waiter", "code": waiter['code'], "nick": nick,})
else:
await self.send(json.dumps({'type': 'loginResponse', "error": "USER_INPUT", "description": "Pseudo déjà utilisé"}))
else:
await self.channel_layer.group_add(self.room_id, self.channel_name)
new_participant = await self.add_participant(nick, self.clientId)
self.user = new_participant
print('new_participant')
await self.send(json.dumps({'type': "roomJoined", "clientId": new_participant.clientId, 'id_code': self.room_id, 'identity': new_participant}))
await self.channel_layer.group_send(self.room_id, {'type': 'join.event', "nick": nick, "owner": False, "online": True, "code": ""})
await self.channel_layer.group_send(f'owner__{self.room_id}', {'type': 'join.event', "nick": nick, "owner": False, "online": True, "code": new_participant['code']})
elif type == "acceptParticipant":
code = text_data_json['data']['code']
nick = text_data_json['data']['nick']
self.waiter = False
new_participant = await self.add_participant(nick, str(uuid4()))
await self.del_waiter_db(code)
await self.channel_layer.group_send(f'waiter__{code}', {"type": "accept_room", 'id_code': self.room_id, 'code': new_participant['code']})
elif type == "refusedParticipant":
code = text_data_json['data']['code']
await self.del_waiter_db(code)
await self.channel_layer.group_send(f'waiter__{code}', {"type": "refused_participant"})
elif type == "logAcceptedWaiter":
code = text_data_json['data']['code']
participants = await self.get_participants()
if code in list(map(lambda p: p['code'], participants)):
participant = list(
filter(lambda p: p['code'] == code, participants))[0]
await self.channel_layer.group_discard(f'waiter__{code}', self.channel_name)
print('new user', participant)
self.clientId = participant['clientId']
await self.channel_layer.group_add(self.room_id, self.channel_name)
self.user = participant
self.waiter = False
self.waiter_code = None
await self.send(json.dumps({'type': "roomJoined", "clientId": self.clientId, 'id_code': self.room_id, 'identity': participant}))
await self.channel_layer.group_send(self.room_id, {"type": "join.event", "nick": participant['nick'], "owner": False, "online": True, "code": ''})
await self.channel_layer.group_send(f'owner__{self.room_id}', {"type": "join.event", "nick": participant['nick'], "owner": False, "online": True, "code": participant['code']})
elif type == 'relogin':
code = text_data_json['data']['code']
participants = await self.get_participants()
print('participants', code, participants)
if code in list(map(lambda p: p['code'], participants)):
participant = list(filter(lambda p: p['code'] == code, participants))[0]
self.clientId = participant['clientId']
if participant['clientId'] == self.room.owner['clientId'] and participant['code'] == self.room.owner['code']:
await self.channel_layer.group_add(f'owner__{self.room_id}', self.channel_name)
else:
await self.channel_layer.group_add(self.room_id, self.channel_name)
participant['online'] = True
self.user = participant
await self.connect_participant()
await self.send(json.dumps({'type': "reloged", "clientId": self.clientId, 'id_code': self.room_id, 'identity': participant}))
await self.channel_layer.group_send(self.room_id, {"type": "reconnect.event", 'nick': self.user['nick']})
await self.channel_layer.group_send(f'owner__{self.room_id}', {"type": "reconnect.event", 'nick': self.user['nick']})
else:
await self.send(json.dumps({"type": "reloginError"}))
elif type == "reconnect":
client = text_data_json['data']['clientId']
participants = await self.get_participants()
if client in list(map(lambda p: p['clientId'], participants)):
self.clientId = client
participant = list(filter(lambda p: p['clientId'] == client, participants))[0]
if participant['clientId'] == self.room.owner['clientId'] and participant['code'] == self.room.owner['code']:
print('add in admin')
await self.channel_layer.group_add(f'owner__{self.room_id}', self.channel_name)
else:
print('add in users')
await self.channel_layer.group_add(self.room_id, self.channel_name)
participant['online'] = True
self.user = participant
await self.connect_participant()
await self.send(json.dumps({'type': "reconnected", "clientId": client, 'id_code': self.room_id, 'identity': participant}))
await self.channel_layer.group_send(self.room_id, {"type": "reconnect.event", 'nick': self.user['nick']})
await self.channel_layer.group_send(f'owner__{self.room_id}', {"type": "reconnect.event", 'nick': self.user['nick']})
else:
await self.send(json.dumps({"type": "reconnectError", 'id_code': self.room_id}))
elif type == 'ban':
code = text_data_json['data']["code"]
nick = text_data_json['data']["nick"]
await self.del_participant(code)
await self.channel_layer.group_send(self.room_id, {'type': "ban_participant", "code": code, "nick": nick})
await self.channel_layer.group_send(f'owner__{self.room_id}', {'type': "ban_participant", "code": code, "nick": nick})
async def join_event(self, event):
await self.send(json.dumps({'type': 'joined', 'nick': event['nick'], "owner": event['owner'], "online": event['online'], "code": event["code"]}))
async def accept_room(self, event):
await self.send(json.dumps({'type': 'accept_room', 'id_code': self.room_id, 'code':event["code"]}))
async def accept_waiter(self, event):
await self.send(json.dumps({'type': 'joined', 'nick': event['nick'], "owner": event['owner'], "online": event['online'], "code": event["code"]}))
async def add_waiter(self, event):
await self.send(json.dumps({'type': 'add_waiter', 'nick': event['nick'], "code": event["code"], }))
async def new_parcours(self, event):
await self.send(json.dumps({'type': "add_parcours", "parcours": event['parcours']}))
async def refused_participant(self, event):
await self.send(json.dumps({"type": "refused"}))
async def ban_participant(self, event):
await self.send(json.dumps({"type": "banned", 'nick': event['nick'], "code": event["code"]}))
@database_sync_to_async
def get_participants(self):
return Room.objects.filter(id_code = self.room_id)[0].participants
@database_sync_to_async
def get_room(self):
return Room.objects.filter(id_code = self.room_id)[0]
@database_sync_to_async
def add_participant(self, new, id):
return Room.objects.add_participant(self.room_id, new, id, False, True)
@database_sync_to_async
def del_participant(self, code):
return Room.objects.del_participant(self.room_id, code)
@database_sync_to_async
def add_waiter_db(self, new):
return Room.objects.add_waiter(self.room_id, new)
@database_sync_to_async
def del_waiter_db(self, code):
return Room.objects.del_waiter(self.room_id, code)
@database_sync_to_async
def disconnect_participant(self):
return Room.objects.disconnect(self.room_id, self.user['code'])
@database_sync_to_async
def connect_participant(self):
return Room.objects.connect(self.room_id, self.user['code'])
async def disconnect(self, close_code):
if self.waiter == False and self.user != None:
await self.disconnect_participant()
await self.channel_layer.group_discard(self.room_id, self.channel_name)
await self.channel_layer.group_send(self.room_id, {"type": "disconnect.event", "nick": self.user['nick']})
await self.channel_layer.group_send(f'owner__{self.room_id}', {"type": "disconnect.event", "nick": self.user['nick']})
elif self.waiter == True and self.waiter_code != None:
await self.del_waiter_db(self.waiter_code)
await self.channel_layer.group_send(f'owner__{self.room_id}', {'type': "del_waiter", "code": self.waiter_code})
await self.channel_layer.group_discard(f'waiter__{self.waiter_code}', self.channel_name)
async def disconnect_event(self, event):
await self.send(json.dumps({'type': 'disconnect_participant', "nick": event['nick']}))
async def reconnect_event(self, event):
await self.send(json.dumps({'type': 'reconnect_participant', "nick": event['nick']}))
async def del_waiter(self, event):
await self.send(json.dumps({"type": 'del_waiter', "code": event['code']}))
async def challenge_parcours(self, event):
await self.send(json.dumps({**event}))
async def delete_parcours(self, event):
await self.send(json.dumps({**event}))
async def edit_parcours(self, event):
await self.send(json.dumps({**event}))