chat/admin.py

@@ -1,6 +1,6 @@
 from django.contrib import admin
-from .models import ChatChannelModel, ChatMemberModel, ChatMessageModel
+from .models import ChannelModel, MemberModel, MessageModel
 
-admin.site.register(ChatChannelModel)
-admin.site.register(ChatMemberModel)
-admin.site.register(ChatMessageModel)
+admin.site.register(ChannelModel)
+admin.site.register(MemberModel)
+admin.site.register(MessageModel)

chat/consumers.py

@@ -1,25 +1,20 @@
+import json
 from channels.generic.websocket import WebsocketConsumer
 from asgiref.sync import async_to_sync
-
-from .models import ChatMemberModel, ChatMessageModel
-from profiles.models import BlockModel
-
+from .models import MemberModel, MessageModel
 import time
-import json
 
 class ChatConsumer(WebsocketConsumer):
-
 	def connect(self):
-		
+		channel_id : str = self.scope['path'].split('/')[3]
+
+		self.room_group_name = 'chat' + channel_id
+
 		user = self.scope["user"]
 		if (user.is_anonymous or not user.is_authenticated):
 			return
 
-		channel_id : int = int(self.scope['url_route']['kwargs']['chat_id'])
-
-		self.room_group_name = f'chat{channel_id}'
-
-		if ChatMemberModel.objects.filter(member_id=user.pk, channel_id=int(channel_id)).count() != 1:
+		if MemberModel.objects.filter(member_id=user.pk, channel_id=int(channel_id)).count() != 1:
 			return
 
 		if (self.channel_layer == None):
@@ -34,40 +29,26 @@ class ChatConsumer(WebsocketConsumer):
 
 
 	def receive(self, text_data=None, bytes_data=None):
-
 		if text_data == None:
 			return
 
+		text_data_json = json.loads(text_data)
+		message = text_data_json['message']
+
+		channel_id : int = int(self.scope['path'].split('/')[3])
 		user = self.scope["user"]
 		if (user.is_anonymous or not user.is_authenticated):
 			return
 
-		text_data_json: dict = json.loads(text_data)
-		
-		message = text_data_json.get('message')
-		if (message is None):
-			return
-		
-		receivers_id = text_data_json.get('receivers_id')
-		if (receivers_id is None):
-			return
-
-		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 MemberModel.objects.filter(member_id=user.pk, channel_id=channel_id).count() != 1:
 			return
 
 		if (self.channel_layer == None):
 			return
 
-		message_time: int = int(time.time() * 1000)
-		
-		if (len(receivers_id) == 1 and 
-			BlockModel.objects.filter(blocker=user.pk, blocked=receivers_id[0]) or
-			BlockModel.objects.filter(blocker=receivers_id[0], blocked=user.pk)
-			):
-			return
+		print(message)
 
+		message_time : int = int(time.time() * 1000)
 		async_to_sync(self.channel_layer.group_send)(
 			self.room_group_name,
 			{
@@ -78,17 +59,22 @@ class ChatConsumer(WebsocketConsumer):
 			}
 		)
 		
-		new_message = ChatMessageModel(channel_id = channel_id, author_id = user.pk, content = message, time = message_time).save()
+		new_message = MessageModel()
+		new_message.channel_id = channel_id
+		new_message.author_id = user.pk
+		new_message.content = message
+		new_message.time = message_time
+		new_message.save()
+
 
 	def chat_message(self, event):
 
+		channel_id : int = int(self.scope['path'].split('/')[3])
 		user = self.scope["user"]
 		if (user.is_anonymous or not user.is_authenticated):
 			return
 
-		channel_id : int = int(self.scope['url_route']['kwargs']['chat_id'])
-
-		if ChatMemberModel.objects.filter(member_id = user.pk, channel_id = channel_id).count() != 1:
+		if MemberModel.objects.filter(member_id=user.pk, channel_id=channel_id).count() != 1:
 			return
 
 		self.send(text_data=json.dumps({

chat/models.py

@@ -4,28 +4,21 @@ from django.contrib.auth.models import User
 from django.contrib import admin
 
 # Create your models here.
-class ChatChannelModel(models.Model):
-	
-	def create(self, users_id: [int]):
-		self.save()
-		for user_id in users_id:
-			ChatMemberModel(channel_id = self.pk, member_id = user_id).save()
+class ChannelModel(models.Model):
+	pass
 
-	def get_members_id(self):
-		return [member_channel.member_id for member_channel in ChatMemberModel.objects.filter(channel_id = self.pk)]
-
-class ChatMemberModel(models.Model):
+class MemberModel(models.Model):
 	member_id = IntegerField(primary_key=False)
 	channel_id = IntegerField(primary_key=False)
 
 	def __str__(self):
 		return "member_id: " + str(self.member_id) + ", channel_id: " + str(self.channel_id)
 
-class ChatMessageModel(models.Model):
+class MessageModel(models.Model):
 	channel_id = IntegerField(primary_key=False)
 	author_id = IntegerField(primary_key=False)
 	content = models.CharField(max_length=255)
 	time = IntegerField(primary_key=False)
 
 	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

chat/serializers.py

@@ -1,30 +1,8 @@
 from rest_framework import serializers
+from .models import ChannelModel
 
-from profiles.models import ProfileModel
-
-from .models import ChatChannelModel, ChatMessageModel
-
-class ChatChannelSerializer(serializers.ModelSerializer):
-
-    members_id = serializers.ListField(child = serializers.IntegerField())
+class ChannelSerializer(serializers.ModelSerializer):
 
     class Meta:
-        model = ChatChannelModel
-        fields = ["members_id", "pk"]
-
-    def validate_members_id(self, value):
-        members_id: [int] = value
-        if len(members_id) < 2:
-            raise serializers.ValidationError('Not enought members to create the channel')
-        if len(set(members_id)) != len(members_id):
-            raise serializers.ValidationError('Same member')
-        for member_id in members_id:
-            if not ProfileModel.objects.filter(pk = member_id).exists():
-                raise serializers.ValidationError(f"The profile {member_id} doesn't exists.")
-        return members_id
-
-class ChatMessageSerializer(serializers.Serializer):
-
-    class Meta:
-        model = ChatMessageModel
-        fields = ["channel_id", "author_id", "content", "time"]
+        model = ChannelModel
+        fields = []

chat/tests.py

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

chat/urls.py

@@ -5,5 +5,6 @@ from django.conf.urls.static import static
 from . import views
 
 urlpatterns = [
-    path("", views.ChannelView.as_view(), name="chats_page"),
+    path("<int:pk>", views.ChatView.as_view(), name="chat_page"),
+    path("", views.ChatsView.as_view(), name="chats_page"),
 ]

chat/views.py

@@ -1,45 +1,79 @@
 from rest_framework.views import APIView
 from rest_framework.response import Response
-from rest_framework import permissions, status
+from rest_framework import authentication, permissions, status
 from rest_framework.authentication import SessionAuthentication
-
-from django.http import HttpRequest
-from django.contrib.auth import login
-from django.db.models import QuerySet
+from .models import ChannelModel, MemberModel, MessageModel
 from django.core import serializers
 
-
-from .models import ChatChannelModel, ChatMemberModel, ChatMessageModel
-from .serializers import ChatChannelSerializer, ChatMessageSerializer
-
-class ChannelView(APIView):
-    
-	queryset = ChatChannelModel.objects
-	serializer_class = ChatChannelSerializer
+class ChatView(APIView):
 	permission_classes = (permissions.IsAuthenticated,)
-	authentication_classes = (SessionAuthentication,)	
+	authentication_classes = (SessionAuthentication,)
+	
+	def get(self, request, pk):
+		if (ChannelModel.objects.filter(pk=pk)):
+			return Response({'channel_id': pk}, status=status.HTTP_200_OK)
+		else:
+			return Response("Channel doesn't exist", status=status.HTTP_404_NOT_FOUND)
 
+	def delete(self, request, pk):
+
+		ChannelModel.objects.filter(pk=pk).delete()
+		MessageModel.objects.filter(pk=pk).delete()
+		MemberModel.objects.filter(pk=pk).delete()
+
+		return Response({'channel_id': pk}, status=status.HTTP_200_OK)
+
+class ChatsView(APIView):
 	def post(self, request):
 
-		serializer = self.serializer_class(data = request.data)
-		
-		serializer.is_valid(raise_exception=True)
+		data: dict = request.data
+		users_id = request.data.get("users_id", [])
+		if len(users_id) < 2:
+			return Response('Not enought members to create the channel', status=status.HTTP_400_BAD_REQUEST)
+		if users_id[0] == users_id[1]:
+			return Response('Same member', status=status.HTTP_400_BAD_REQUEST)
 
-		data: dict = serializer.validated_data
+		for user_id1 in users_id:
+			for member1 in MemberModel.objects.filter(member_id=user_id1):
+				for user_id2 in users_id:
+					if user_id1 == user_id2:
+						continue
+					for member2 in MemberModel.objects.filter(member_id=user_id2):
+						if (member1.channel_id == member2.channel_id):
+							messages = MessageModel.objects.filter(channel_id=member1.channel_id).order_by("time")
+							messages = serializers.serialize("json", messages) 
+							return Response({'channel_id': member1.channel_id, 'messages':messages}, status=status.HTTP_200_OK)
+							
+		new_channel = ChannelModel()
+		new_channel.save()	
 
-		members_id = data.get("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)
+		for user_id in users_id:
 
-		for member_channel in ChatMemberModel.objects.filter(member_id = members_id[0]):
-			channel_id: int = member_channel.channel_id
-			if not ChatChannelModel.objects.filter(pk = channel_id).exists():
-				continue
-			channel: ChatChannelModel = ChatChannelModel.objects.get(pk = channel_id)
-			if set(channel.get_members_id()) == set(members_id):
-				messages = ChatMessageModel.objects.filter(channel_id = channel_id).order_by("time")
-				messages = serializers.serialize("json", messages)
-				return Response({'channel_id': channel_id, 'messages': messages}, status=status.HTTP_200_OK)				
+			new_member = MemberModel()
+			new_member.channel_id = new_channel.pk
+			new_member.member_id = user_id
+			new_member.save()
 
-		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.pk}, status=status.HTTP_201_CREATED)
+
+	def delete(self, request):
+
+		data: dict = request.data
+		users_id = request.data.get("users_id", [])
+
+		#print(list(MemberModel.objects.all()))
+
+		for user_id1 in users_id:
+			for member1 in MemberModel.objects.filter(member_id=user_id1):
+				for user_id2 in users_id:
+					if user_id1 == user_id2:
+						break
+					for member2 in MemberModel.objects.filter(member_id=user_id2):
+						if (member1.channel_id == member2.channel_id):
+							MessageModel.objects.filter(channel_id=member1.channel_id).delete()
+							member1.delete()
+							member2.delete()
+							ChannelModel.objects.get(pk=member1.channel_id).delete()
+							return Response("Channel removed", status=status.HTTP_200_OK)
+
+		return Response("Channel doesn't exist", status=status.HTTP_404_NOT_FOUND)

frontend/static/js/api/chat/channel.js

@@ -35,9 +35,7 @@ class Channel {
 		this.chatSocket.close();
 	}
 
-	updateMessages(messages)
-	{
-		console.log(messages);
+	updateMessages(messages) {
 		messages = JSON.parse(messages);
 		let new_messages = [];
 
@@ -56,14 +54,13 @@ class Channel {
 		return new_messages;
 	}
 
-	async sendMessageChannel(message, receivers_id) {
+	async sendMessageChannel(message) {
 
 		if (this.chatSocket == undefined)
 			return;
 
 		this.chatSocket.send(JSON.stringify({
-			'message':message,
-			'receivers_id':receivers_id,
+			'message':message
 		}));
 	}
 

frontend/static/js/api/chat/channels.js

@@ -6,18 +6,18 @@ class Channels {
 		this.client = client;
 	}
 
-	async createChannel(members_id, reload) {
+	async createChannel(users_id, reload) {
 		
 		let null_id = false;
-		members_id.forEach(member_id => {
-			if (member_id == null)
+		users_id.forEach(user_id => {
+			if (user_id == null)
 				null_id = true;
 		});
 		if (null_id)
-			return console.log(members_id, "createChannel error, null id;");
+			return console.log(users_id, "createChannel error, null id;");
 
 		let response = await this.client._post("/api/chat/", {
-			members_id:members_id
+			users_id:users_id
 		});
 
 		let data = await response.json();
@@ -28,13 +28,12 @@ class Channels {
 		let messages = undefined;
 		if (exit_code == 200)
 			messages = data.messages;
-		
-		return new Channel(this.client, data.channel_id, members_id, messages, reload);
+		return new Channel(this.client, data.channel_id, users_id, messages, reload);
 	}
 
-	async deleteChannel(members_id) {
+	async deleteChannel(users_id) {
 		let response = await this.client._delete("/api/chat/", {
-			members_id:members_id
+			users_id:users_id
 		});
 
 		let data = await response.json();

frontend/static/js/api/client.js

@@ -38,11 +38,10 @@ class Client
 		return this.logged;	
 	}
 
-	async _get(uri, data)
+	async _get(uri)
 	{
 		let response = await fetch(this._url + uri, {
 			method: "GET",
-			body: JSON.stringify(data),
 		});
 		return response;
 	}

frontend/static/js/api/profile.js

@@ -12,9 +12,8 @@ class Profile
 		 */
 		this.client = client;
 		this.username = username;
-		this.avatar_url = avatar_url;
-		this.user_id = user_id;
-		this.isBlocked = false;
+		this.avatar_url = avatar_url
+		this.user_id = user_id
 	}
 
 	async init(user_id)
@@ -29,21 +28,7 @@ class Profile
 		this.user_id = response_data.user_id;
 		this.username = response_data.username;
 		this.avatar_url = response_data.avatar_url;
-
-		let block_response = await this.client._get("/api/profiles/block");
-
-		if (block_response.status == 404)
-			return
-
-		let block_data = await block_response.json();
-		let block_list = JSON.parse(block_data);
-		block_list.forEach(block => {
-			let blocker = block.fields.blocker;
-			let blocked = block.fields.blocked;
-			if (blocker == this.client.me.user_id && blocked == user_id)
-				return this.isBlocked = true;
-		});
 	}
 }
 
-export {Profile}
+export {Profile}

frontend/static/js/api/profiles.js

@@ -36,30 +36,13 @@ class Profiles
 	async block(user_id) {
 
 		// blocker & blocked
-		let response = await this.client._post("/api/profiles/block", { 
-			users_id:[this.client.me.user_id, user_id],
-		});
+		let response = await this.client._post("/api/block/", 
+			[this.client.me.user_id, user_id],
+		);
 
 		let data = await response.json();
-		console.log(response.status);
-		console.log(data);
-		return data;
 
 	}
-
-	async deblock(user_id) {
-
-		// blocker & blocked
-		let response = await this.client._delete("/api/profiles/block", { 
-			users_id:[this.client.me.user_id, user_id],
-		});
-
-		let data = await response.json();
-		console.log(response.status);
-		console.log(data);
-		return data;
-		
-	}
 }
 
 export {Profiles}

frontend/static/js/views/ProfilePageView.js

@@ -14,47 +14,32 @@ export default class extends AbstractView {
 		if (profile === null)
 			return 1;
 
-        this.profile = await client.profiles.getProfile(this.user_id);
-		this.info = document.getElementById("info");
+		let info = document.getElementById("info");
 
 		// Username
         let username = document.createElement("a");
 		username.id = "username";
-        username.appendChild(document.createTextNode(this.profile.username));
-		this.info.appendChild(username);
+        username.appendChild(document.createTextNode(profile.username));
+		info.appendChild(username);
 
-		this.info.appendChild(document.createElement("br"));
+		info.appendChild(document.createElement("br"));
 
 		// Avatar
         let avatar = document.createElement("img");
 		avatar.id = "avatar";
-        avatar.src = this.profile.avatar_url;
-		this.info.appendChild(avatar);
-
-		await this.blockButton();
-    }
-
-	async blockButton() {
+        avatar.src = profile.avatar_url;
+		info.appendChild(avatar);
+		
 		// Block option
-		if (client.me.user_id != this.user_id) {
-			let block = document.getElementById("block") || document.createElement("a");
-			block.id = "block";
-			block.innerText = "";
-			block.onclick = async () => {
-				if (!this.profile.isBlocked)
-					await client.profiles.block(this.user_id);
-				else
-					await client.profiles.deblock(this.user_id);
-				this.profile = await client.profiles.getProfile(this.user_id);
-				this.blockButton();
-			};
-			if (this.profile.isBlocked)
-				block.appendChild(document.createTextNode("Deblock"));
-			else
-				block.appendChild(document.createTextNode("Block"));
-			this.info.appendChild(block);
-		}
-	}
+		let block = document.createElement("a");
+		block.id = "block";
+		block.addEventListener("click", async () => {
+			if (client.me.user_id != user.user_id) {
+			}
+		});
+		block.appendChild(document.createTextNode("Block"));
+		info.appendChild(block);
+    }
 
     async getHtml() {
         return `

frontend/static/js/views/Search.js

@@ -100,7 +100,6 @@ export default class extends AbstractView {
 
 	async chat() {
 
-		let users = await client.profiles.all();
 		let logged = await client.isAuthentificate();
 		/*let reload = document.getElementById("messages");
 		if (reload != null)
@@ -136,7 +135,7 @@ export default class extends AbstractView {
 		// les messages, réecriture seulement du dernier 
 		let i = 0;
 		client.channel.messages.forEach((message) => {
-			if (messages.children[i] == null || message.content != messages.children[i].innerText) {
+			if (messages[i] == null || message != messages.children[i].innerText) {
 				let text = document.createElement("p");
 				text.appendChild(document.createTextNode(message.content));
 				if (message.author_id == client.me.user_id)
@@ -159,25 +158,21 @@ export default class extends AbstractView {
 			chat_input.maxLength=255;
 			chat.appendChild(chat_input);
 			
-			chat_input.onkeydown = async () => {
+			chat_input.addEventListener("keydown", async () => {
 				if (event.keyCode == 13 && client.channel != undefined) {
 					//let chat_input = document.getElementById("input_chat");
 					let chat_text = chat_input.value;
 
-					let receivers_id = [];
-					client.channel.members_id.forEach((member_id) => {
-						if (member_id != client.me.user_id)
-							receivers_id.push(users.filter(user => user.user_id == member_id)[0].user_id);
-					});
-					await client.channel.sendMessageChannel(chat_text, receivers_id)
+					await client.channel.sendMessageChannel(chat_text)
 
 					// Reset
 					chat_input.value = "";
 				}
-			};
+			});
 		}
 
 		// nom des membres du chat
+		let users = await client.profiles.all();
 		let members = document.createElement("h2");
 		members.id = "members";
 		let usernames = "";

profiles/admin.py

@@ -1,7 +1,6 @@
 from django.contrib import admin
 
-from .models import ProfileModel, BlockModel
+from .models import ProfileModel
 
 # Register your models here.
-admin.site.register(ProfileModel)
-admin.site.register(BlockModel)
+admin.site.register(ProfileModel)

profiles/urls.py

@@ -9,7 +9,5 @@ urlpatterns = [
     path("me", viewsets.MyProfileViewSet.as_view({'patch': 'partial_update', 'get': 'retrieve'}), name="my_profile_page"),
     path("<int:pk>", viewsets.ProfileViewSet.as_view({'get': 'retrieve'}), name="profile_page"),
     path("", viewsets.ProfileViewSet.as_view({'get': 'list'}), name="profiles_list"),
-	path("block", views.BlocksView.as_view(), name="block_page"),
-	path("block/<int:pk>", views.BlockView.as_view(), name="block_page"),
-
+	path("block", views.BlockView.as_view(), name="block_page"),
 ] + static("/static/avatars/", document_root="./avatars")

profiles/views.py

@@ -2,65 +2,17 @@ from rest_framework.views import APIView
 from rest_framework.response import Response
 from rest_framework import authentication, permissions, status
 from rest_framework.authentication import SessionAuthentication
-from rest_framework.renderers import JSONRenderer
 from django.core import serializers
-from .models import BlockModel
 
 class BlockView(APIView):
 	permission_classes = (permissions.IsAuthenticated,)
 	authentication_classes = (SessionAuthentication,)
+	
+	def post(self, request, pk):
+		pass
 
 	def get(self, request, pk):
-		block = BlockModel.objects.filter(pk=pk)
-		if (block):
-			return Response(serializers.serialize("json", block), status=status.HTTP_200_OK)
-		else:
-			return Response("Not Found", status=status.HTTP_404_NOT_FOUND)
+		pass
 
-
-class BlocksView(APIView):
-	permission_classes = (permissions.IsAuthenticated,)
-	authentication_classes = (SessionAuthentication,)
-
-	def get(self, request):
-		blocks = BlockModel.objects.filter(blocker=request.user.pk)
-		if (blocks):
-			return Response(serializers.serialize("json", BlockModel.objects.filter(blocker=request.user.pk)), status=status.HTTP_200_OK)
-		else:
-			return Response({}, status=status.HTTP_404_NOT_FOUND)
-
-	def post(self, request):
-		data: dict = request.data
-		users_id = request.data.get("users_id", None)
-
-		if (users_id == None):
-			return Response({"Error"}, status=status.HTTP_400_BAD_REQUEST)
-
-		if (BlockModel.objects.filter(blocker=users_id[0], blocked=users_id[1])):
-			return Response({"Already Exist"}, status=status.HTTP_409_CONFLICT)
-
-		new_block = BlockModel()
-		new_block.blocker = users_id[0]
-		new_block.blocked = users_id[1]
-		new_block.save()
-
-		return Response({"block_id": new_block.pk}, status=status.HTTP_201_CREATED)
-
-	def delete(self, request):
-		data: dict = request.data
-		users_id = request.data.get("users_id", None)
-
-		if (users_id == None):
-			return Response({"Error"}, status=status.HTTP_400_BAD_REQUEST)
-
-		block = BlockModel.objects.filter(blocker=users_id[0], blocked=users_id[1])
-
-		print(list(block))
-		if (block.count() > 1):
-			return Response("Not normal >:[", status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-		
-		if (not block):
-			return Response("Don't exist", status=status.HTTP_404_NOT_FOUND)
-
-		block.delete()
-		return Response("Deleted", status=status.HTTP_200_OK)
+	def delete(self, request, pk):
+		pass

tournament/serializers.py

@@ -27,6 +27,7 @@ class TournamentSerializer(serializers.ModelSerializer):
 		if (value < 2):
 			raise serializers.ValidationError("The numbers of players must be greather than 2.")
 		return value
+
 	def validate_nb_players_by_game(self, value: int):
 		if (value < 2):
 			raise serializers.ValidationError("The numbers of players by game must be greather than 2.")