add block option

README.md

@@ -22,10 +22,17 @@ pip install -r requirements.txt
 ```
 - Setup database
 ```
-python manage.py runserver makemigrations profiles
+python manage.py makemigrations games
-python manage.py migrate profiles
+python manage.py makemigrations profiles
+python manage.py makemigrations chat
+python manage.py migrate
 ```
 - Start the developpement server
 ```
 python manage.py runserver 0.0.0.0:8000
 ```
+
+coc nvim
+```
+pip install django-stubs
+```

accounts/views/delete.py

@@ -1,6 +1,7 @@
 from rest_framework.views import APIView
 from rest_framework import permissions, status
 from rest_framework.response import Response
+from django.contrib.auth import logout
 from django.http import HttpRequest
 from rest_framework.authentication import SessionAuthentication
 
@@ -16,4 +17,5 @@ class DeleteView(APIView):
 		if (request.user.check_password(password) == False):
 			return Response({"password": ["Password wrong."]})
 		request.user.delete()
+		logout(request)
 		return Response("user deleted", status=status.HTTP_200_OK)

accounts/views/logged.py

@@ -15,4 +15,4 @@ class LoggedView(APIView):
 	def get(self, request: HttpRequest):
 		if (request.user.is_authenticated):
 			return Response({'id': request.user.pk}, status=status.HTTP_200_OK)
-		return Response('false', status=status.HTTP_200_OK)
+		return Response('false', status=status.HTTP_200_OK)

accounts/views/register.py

@@ -15,4 +15,4 @@ class RegisterView(APIView):
 			if user:
 				login(request, user)
 				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)

chat/admin.py

@@ -1,3 +1,6 @@
 from django.contrib import admin
+from .models import ChannelModel, MemberModel, MessageModel
 
-# Register your models here.
+admin.site.register(ChannelModel)
+admin.site.register(MemberModel)
+admin.site.register(MessageModel)

chat/consumers.py

@@ -1,10 +1,25 @@
 import json
 from channels.generic.websocket import WebsocketConsumer
 from asgiref.sync import async_to_sync
+from .models import MemberModel, MessageModel
+from profiles.models import BlockModel
+import time
 
 class ChatConsumer(WebsocketConsumer):
 	def connect(self):
-		self.room_group_name = 'test'
+		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
+
+		if MemberModel.objects.filter(member_id=user.pk, channel_id=int(channel_id)).count() != 1:
+			return
+
+		if (self.channel_layer == None):
+			return
 
 		async_to_sync(self.channel_layer.group_add)(
 			self.room_group_name,
@@ -14,23 +29,66 @@ class ChatConsumer(WebsocketConsumer):
 		self.accept()
 
 
-	def receive(self, text_data):
+	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']
+		receivers_id = text_data_json['receivers_id']
+
+		print(text_data)
+
+		channel_id : int = int(self.scope['path'].split('/')[3])
+		user = self.scope["user"]
+		if (user.is_anonymous or not user.is_authenticated):
+			return
+
+		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
 
 		async_to_sync(self.channel_layer.group_send)(
 			self.room_group_name,
 			{
 				'type':'chat_message',
-				'message':message
+				'author_id':user.pk,
+				'content':message,
+				'time':message_time,
 			}
 		)
+		
+		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):
-		message = event['message']
+
+		channel_id : int = int(self.scope['path'].split('/')[3])
+		user = self.scope["user"]
+		if (user.is_anonymous or not user.is_authenticated):
+			return
+
+		if MemberModel.objects.filter(member_id=user.pk, channel_id=channel_id).count() != 1:
+			return
 
 		self.send(text_data=json.dumps({
 			'type':'chat',
-			'username':self.scope["user"].username,
+			'author_id':event['author_id'],
-			'message':message
+			'content':event['content'],
+			'time': event['time'],
 		}))

chat/models.py

@@ -1,3 +1,24 @@
 from django.db import models
+from django.db.models import IntegerField
+from django.contrib.auth.models import User
+from django.contrib import admin
 
 # Create your models here.
+class ChannelModel(models.Model):
+	pass
+
+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 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

chat/routing.py

@@ -2,5 +2,5 @@ from django.urls import re_path
 from . import consumers
 
 websocket_urlpatterns = [
-	re_path(r'ws/socket-server/', consumers.ChatConsumer.as_asgi())
+	re_path(r'ws/chat/(?P<chat_id>\d+)/$', consumers.ChatConsumer.as_asgi())
 ]

chat/serializers.py

@@ -0,0 +1,8 @@
+from rest_framework import serializers
+from .models import ChannelModel
+
+class ChannelSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = ChannelModel
+        fields = []

chat/urls.py

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

chat/views.py

@@ -1,3 +1,79 @@
-from django.shortcuts import render
+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 .models import ChannelModel, MemberModel, MessageModel
+from django.core import serializers
 
-# Create your views here.
+class ChatView(APIView):
+	permission_classes = (permissions.IsAuthenticated,)
+	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):
+
+		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)
+
+		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()	
+
+		for user_id in users_id:
+
+			new_member = MemberModel()
+			new_member.channel_id = new_channel.pk
+			new_member.member_id = user_id
+			new_member.save()
+
+		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/css/accounts/login.css

@@ -9,4 +9,4 @@
     margin-right: auto;
 	margin-top: 90px;
     border: 15px black solid;
-}
+}

frontend/static/css/accounts/register.css

@@ -9,4 +9,4 @@
     margin-right: auto;
 	margin-top: 90px;
     border: 15px black solid;
-}
+}

frontend/static/css/index.css

@@ -1,7 +1,8 @@
+
 body {
-    margin: 10;
+    margin: 0.5em;
     font-family: 'Quicksand', sans-serif;
-    font-size: 18px;
+    font-size: 30px;
 }
 
 a {

frontend/static/css/me.css

@@ -0,0 +1,18 @@
+#app #main .account
+{
+	background-color: red;
+}
+
+#app #main
+{
+	width: 60%;
+	display: flex;
+	margin-left: auto;
+	margin-right: auto;
+	flex-direction: column;
+}
+
+#app #main .profile
+{
+	background-color: green;
+}

frontend/static/css/profile.css

@@ -0,0 +1,20 @@
+#app #avatar
+{
+	height: 100px;
+	width: 100px;
+}
+
+#app #username
+{
+	font-size: 0.8em;
+}
+
+#app #block {
+	cursor: pointer;
+	font-size: 0.7em;
+	text-decoration: underline;
+}
+
+#app {
+	margin-top: 20px;
+}

frontend/static/css/profiles/profile.css

@@ -1,11 +0,0 @@
-#app #avatar
-{
-	height: 100px;
-	width: 100px;
-}
-
-#app #username
-{
-	height: 100px;
-	width: 100px;
-}

frontend/static/css/profiles/profiles.css

@@ -1,11 +0,0 @@
-#app .item img
-{
-	height: 100px;
-	width: 100px;
-}
-
-#app .item a
-{
-	height: 100px;
-	width: 100px;
-}

frontend/static/css/search.css

@@ -0,0 +1,104 @@
+#app img
+{
+	max-height: 3em;
+	max-width: 3em;
+}
+
+#app ul
+{
+	font-size: 0.75em;
+	margin: 0.25em 0 0 0;
+	padding: 0 0 0 0;
+	list-style-type: none;
+	max-height: 80vh;
+	overflow: auto;
+}
+
+#app li
+{
+	margin: 0.25em 0.25em 0 0;
+}
+
+#app #chats {
+	overflow: hidden;
+	display: flex;
+	text-align: left;
+}
+#app #users {
+	margin: 0em 1.0em 0em 0.05em;
+}
+
+#app #chat {
+	position: relative;
+	max-height: 100vh;
+	width: 100vh;
+	/*border: 2px	solid green;*/
+	overflow: hidden;
+}
+
+#app #members {
+	font-size: 1em;
+}
+
+#app #add_chat_off {
+	text-decoration: underline;
+	cursor: pointer;
+}
+
+#app #add_chat_on {
+	cursor: pointer;
+}
+
+#app #messages {
+	max-height: 60vh;
+	overflow: scroll;
+	overflow-y: scroll;
+	overflow-x: hidden;
+	font-size: 0.75em;
+}
+
+#app #input_user{
+	color: green;
+	width: 8.5em;
+	height: 1.1em;
+	font-size: 0.65em;
+	border: none;
+	outline: none;
+	border-bottom: 0.15em solid green;
+}
+
+#app #input_chat{
+	position: sticky;
+	bottom: 0;
+	/*width: calc(100% - 8px);*/
+	width: 100%;
+	border: none;
+	outline: none;
+	border-bottom: 0.2em solid green;
+	caret-color: green;
+	color: green;
+	font-size: 16px;
+}
+
+#app #you {
+	text-align: left;
+	position: relative;
+	max-width: 48%;
+	left: 0.5em;
+	margin: 0.5em 0 0 0;
+	color: green;
+
+	word-wrap: break-word;
+}
+
+#app #other {
+	text-align: right;
+	position: relative;
+	max-width: 48%;
+	margin: 0.5em 0 0 auto;
+	right: 0.5em;
+	color: red;
+
+	/* permet le retour à la ligne à la place de dépasser*/
+	word-wrap: break-word;
+}

frontend/static/js/api/MyProfile.js

@@ -0,0 +1,19 @@
+import { Profile } from "./profile.js";
+
+class MyProfile extends Profile
+{
+	async change_avatar(form_data)
+	{
+		let response = await this.client._patch_file(`/api/profiles/me`, form_data);
+		let response_data = await response.json()
+
+		return response_data;
+	}
+
+	async init()
+	{
+		super.init("me");
+	}
+}
+
+export {MyProfile}

frontend/static/js/api/account.js

@@ -1,7 +1,15 @@
+import { Client } from "./client.js";
+
 class Account
 {
+	/**
+	 * @param  {Client} client
+	 */
 	constructor (client)
 	{
+		/**
+		 * @type  {Client} client
+		 */
 		this.client = client;
 	}
 	
@@ -28,7 +36,6 @@ class Account
 			this.client._logged = false;
 			return null;			
 		}
-		console.log(response_data)
 		if (response_data == "user deleted")
 			this.client._logged = false;
 		return response_data;
@@ -55,7 +62,7 @@ class Account
 
 		if (JSON.stringify(response_data) == JSON.stringify({'detail': 'Authentication credentials were not provided.'}))
 		{
-			this.client._logged = false;
+			this.client._;
 			return null;
 		}
 		return response_data;

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

@@ -0,0 +1,78 @@
+import {Message} from "./message.js"
+
+class Channel {
+	constructor(client, channel_id, members_id, messages, reload) {
+		this.client = client;
+		this.channel_id = channel_id;
+		this.members_id = members_id;
+		this.messages = [];
+		if (messages != undefined)
+			this.updateMessages(messages);
+
+		this.connect(reload);
+	}
+
+	// reload = function to use when we receive a message
+	async connect(reload) {
+		let url = `ws://${window.location.host}/ws/chat/${this.channel_id}/`;
+
+		this.chatSocket = new WebSocket(url);
+		this.chatSocket.onmessage = (event) =>{
+			let data = JSON.parse(event.data)
+
+			this.messages.push(new Message(
+				this.channel_id,
+				data.author_id,
+				data.content,
+				data.time,
+			));
+
+			reload();
+		};
+	}
+
+	async disconnect() {
+		this.chatSocket.close();
+	}
+
+	updateMessages(messages) {
+		messages = JSON.parse(messages);
+		let new_messages = [];
+
+		messages.forEach((message) => {
+			message = message["fields"];
+			new_messages.push(new Message(
+				message["channel_id"],
+				message["author_id"],
+				message["content"],
+				message["time"],
+			));
+		});
+
+		//console.log(new_messages);
+		this.messages = new_messages;
+		return new_messages;
+	}
+
+	async sendMessageChannel(message, receivers_id) {
+
+		if (this.chatSocket == undefined)
+			return;
+
+		this.chatSocket.send(JSON.stringify({
+			'message':message,
+			'receivers_id':receivers_id,
+		}));
+	}
+
+	async deleteChannel() {
+		let response = await this.client._delete("/api/chat/" + this.channel_id, {
+		});
+
+		let data = await response.json();
+		return data;
+	}
+
+}
+
+export {Channel}

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

@@ -0,0 +1,46 @@
+import {Channel} from "./channel.js"
+import {Message} from "./message.js"
+
+class Channels {
+	constructor(client) {
+		this.client = client;
+	}
+
+	async createChannel(users_id, reload) {
+		
+		let null_id = false;
+		users_id.forEach(user_id => {
+			if (user_id == null)
+				null_id = true;
+		});
+		if (null_id)
+			return console.log(users_id, "createChannel error, null id;");
+
+		let response = await this.client._post("/api/chat/", {
+			users_id:users_id
+		});
+
+		let data = await response.json();
+		let exit_code = await response.status;
+		if (exit_code >= 300)
+			return undefined;
+
+		let messages = undefined;
+		if (exit_code == 200)
+			messages = data.messages;
+		return new Channel(this.client, data.channel_id, users_id, messages, reload);
+	}
+
+	async deleteChannel(users_id) {
+		let response = await this.client._delete("/api/chat/", {
+			users_id:users_id
+		});
+
+		let data = await response.json();
+		console.log(response.status)
+		return data;
+	}
+
+}
+
+export {Channels}

frontend/static/js/api/chat/message.js

@@ -0,0 +1,10 @@
+class Message {
+	constructor(channel_id, author_id, content, time) {
+		this.channel_id = channel_id;
+		this.author_id = author_id;
+		this.content = content;
+		this.time = time;
+	}
+}
+
+export {Message}

frontend/static/js/api/client.js

@@ -1,6 +1,8 @@
 import { Account } from "./account.js";
-import { Profile } from "./profile.js";
+import { MatchMaking } from "./matchmaking.js";
 import { Profiles } from "./profiles.js";
+import { Channels } from './chat/channels.js';
+import { MyProfile } from "./MyProfile.js";
 
 function getCookie(name)
 {
@@ -19,7 +21,11 @@ class Client
 		this._url = url;
 		this.account = new Account(this);
 		this.profiles = new Profiles(this);
+		this.matchmaking = new MatchMaking(this);
 		this._logged = undefined;
+
+		this.channels = new Channels(this);
+		this.channel = undefined;
 	}
 
 	async isAuthentificate()
@@ -29,10 +35,11 @@ class Client
 		return this.logged;	
 	}
 
-	async _get(uri)
+	async _get(uri, data)
 	{
 		let response = await fetch(this._url + uri, {
 			method: "GET",
+			body: JSON.stringify(data),
 		});
 		return response;
 	}
@@ -88,15 +95,23 @@ class Client
         return response;
     }
 
+	async _update_logged(state)
+	{
+		if (!this.logged && state)
+		{
+			this.me = new MyProfile(this);
+			await this.me.init();
+		}
+		this.logged = state;
+	}
+
 	async login(username, password)
 	{
 		let response = await this._post("/api/accounts/login", {username: username, password: password})
 		let data = await response.json();
 		if (data.id != undefined)
 		{
-			this.me = new Profile(this)
+			await this._update_logged(true);
-			await this.me.init(data.id)
-			this.logged = true;
 			return null;
 		}
 		return data;
@@ -105,7 +120,7 @@ class Client
 	async logout()
 	{
 		await this._get("/api/accounts/logout");
-		this.logged = false;
+		await this._update_logged(false);
 	}
 
 	async _test_logged()
@@ -114,10 +129,7 @@ class Client
 		let data = await response.json();
 
 		if (data.id !== undefined)
-		{
+			await this._update_logged(true);
-			this.me = new Profile(this)
-			await this.me.init(data.id)
-		}
 		return data.id !== undefined;
 	}
 }

frontend/static/js/api/matchmaking.js

@@ -0,0 +1,37 @@
+import { Client } from "./client.js";
+
+class MatchMaking
+{
+	/**
+	 * @param  {Client} client
+	 */
+	constructor(client)
+	{
+		/**
+		 * @type {client}
+		 */
+		this.client = client
+	}
+		
+	async start(func)
+	{
+		if (!await this.client.isAuthentificate())
+			return null;
+		
+		let url = `wss://${window.location.host}/ws/matchmaking/`;
+		
+		this._chatSocket = new WebSocket(url);
+		
+		this._chatSocket.onmessage = function (event) {
+			const data = JSON.parse(event.data);
+			func(data.game_id)
+		};
+	}
+
+	async stop()
+	{
+		this._chatSocket.close()
+	}
+}
+
+export {MatchMaking}

frontend/static/js/api/profile.js

@@ -1,35 +1,45 @@
+import { Client } from "./client.js";
+
 class Profile
 {
+	/**
+	 * @param  {Client} client
+	 */
 	constructor (client, username = undefined, avatar_url = undefined, user_id = undefined)
 	{
+		/**
+		 * @type  {Client} client
+		 */
 		this.client = client;
 		this.username = username;
-		this.avatar_url = avatar_url
+		this.avatar_url = avatar_url;
-		this.user_id = user_id
+		this.user_id = user_id;
+		this.isBlocked = false;
 	}
 
-	async init(id)
+	async init(user_id)
 	{
-		let response = await this.client._get(`/api/profiles/${id}`);
+		let response = await this.client._get(`/api/profiles/${user_id}`);
 		let response_data = await response.json();
 
-		this.id = id;
+		this.user_id = response_data.user_id;
 		this.username = response_data.username;
 		this.avatar_url = response_data.avatar_url;
-	}
 
-	async change_avatar(form_data)
+		let block_response = await this.client._get("/api/profiles/block");
-	{
-		let response = await this.client._patch_file(`/api/profiles/${this.id}`, form_data);
-		let response_data = await response.json()
 
-		return response_data;
+		if (block_response.status == 404)
-	}
+			return
 
-	async setData (data)
+		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

@@ -2,8 +2,14 @@ import { Profile } from "./profile.js";
 
 class Profiles
 {
+	/**
+	 * @param  {Client} client
+	 */
 	constructor (client)
 	{
+		/**
+		 * @type {Client} client
+		 */
 		this.client = client
 	}
 
@@ -25,6 +31,34 @@ class Profiles
 		await profile.init(user_id);
 		return profile;
 	}
+
+	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 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}
+export {Profiles}

frontend/static/js/index.js

@@ -1,17 +1,19 @@
+import { Client } from "./api/client.js";
+
 import LoginView from "./views/accounts/LoginView.js";
 import Dashboard from "./views/Dashboard.js";
-import Settings from "./views/Settings.js";
 import Search from "./views/Search.js";
-import Chat from "./views/Chat.js";
 import HomeView from "./views/HomeView.js";
 import RegisterView from "./views/accounts/RegisterView.js";
 import LogoutView from "./views/accounts/LogoutView.js";
+import GameView from "./views/Game.js"
 
-import { Client } from "./api/client.js";
+import PageNotFoundView from './views/PageNotFoundView.js' 
-import AbstractRedirectView from "./views/AbstractRedirectView.js";
+
+import AbstractRedirectView from "./views/abstracts/AbstractRedirectView.js";
 import MeView from "./views/MeView.js";
-import ProfilePageView from "./views/profiles/ProfilePageView.js";
+import ProfilePageView from "./views/ProfilePageView.js";
-import ProfilesView from "./views/profiles/ProfilesView.js";
+import MatchMakingView from "./views/MatchMakingView.js";
 
 let client = new Client(location.protocol + "//" + location.host)
 
@@ -33,19 +35,18 @@ const navigateTo = async (uri) => {
         history.pushState(null, null, uri);
 };
 
-const router = async (uri = "") => {
+const router = async (uri) => {
     const routes = [
         { path: "/", view: Dashboard },
-        { path: "/profiles", view: ProfilesView},
         { path: "/profiles/:id", view: ProfilePageView },
-        { path: "/settings", view: Settings },
         { path: "/login", view: LoginView },
         { path: "/logout", view: LogoutView },
         { path: "/register", view: RegisterView },
         { path: "/search", view: Search },
-        { path: "/chat", view: Chat },
         { path: "/home", view: HomeView },
         { path: "/me", view: MeView },
+        { path: "/matchmaking", view: MatchMakingView },
+        { path: "/game/offline", view: GameView },
     ];
 
     // Test each route for potential match
@@ -60,7 +61,10 @@ const router = async (uri = "") => {
 
     if (!match) {
         match = {
-            route: routes[0],
+            route: {
+				path: uri,
+				view: PageNotFoundView
+			},
             result: [uri]
         };
     }
@@ -75,6 +79,7 @@ const router = async (uri = "") => {
 
 	lastView = view;
 
+    await client.isAuthentificate();
     let content = await view.getHtml();
     if (content == null)
         return 1;
@@ -86,7 +91,7 @@ const router = async (uri = "") => {
     return 0;
 };
 
-window.addEventListener("popstate", router);
+window.addEventListener("popstate", function() {router(location.pathname)});
 
 document.addEventListener("DOMContentLoaded", () => {
     document.body.addEventListener("click", e => {

frontend/static/js/utils/formUtils.js

@@ -0,0 +1,18 @@
+function clear(property_name, elements_id)
+{
+	elements_id.forEach(element_id => {
+		let element = document.getElementById(element_id)
+		element[property_name] = ""
+	});	
+}
+
+function fill_errors(errors, property_name)
+{
+	Object.keys(errors).forEach(error_field =>
+	{
+		let element = document.getElementById(error_field);
+		element[property_name] = errors[error_field];
+	});	
+}
+
+export {fill_errors, clear}

frontend/static/js/views/Chat.js

@@ -1,56 +0,0 @@
-import AbstractAuthentifiedView from "./AbstractAuthentifiedView.js";
-
-export default class extends AbstractAuthentifiedView {
-    constructor(params) {
-        super(params, "Chat");
-
-		let url = `ws://${window.location.host}/ws/socket-server/`
-
-		this.chatSocket = new WebSocket(url)
-		this.chatSocket.onmessage = function(e){
-			let data = JSON.parse(e.data)
-			console.log('Data:', data)
-			if (data.type === 'chat') {
-				let messages = document.getElementById('messages')
-
-				let username = data.username === null || data.username.length <= 0 ? "NoName" : data.username;
-				messages.insertAdjacentHTML('beforeend', `
-					<div><p>${username}: ${data.message}</p></div>
-				`)
-			}
-
-		}
-    }
-
-	async postInit() {
-		let form = document.getElementById('form')
-		form.addEventListener('submit', (e)=> {
-			e.preventDefault()
-			let message = e.target.message.value
-			this.chatSocket.send(JSON.stringify({
-				'message':message
-			}))
-			form.reset()
-		})
-
-	}
-
-	async leavePage() {
-		this.chatSocket.close();
-	}
-
-    async getHtml() {
-        return `
-			<h1>Chat</h1>
-
-			<form id="form">
-				<input type="text" name="message" placeholder="message"/>
-			</form>
-
-			<div id="messages">
-
-			</div>
-
-        `;
-    }
-}

frontend/static/js/views/Dashboard.js

@@ -1,4 +1,4 @@
-import AbstractView from "./AbstractView.js";
+import AbstractView from "./abstracts/AbstractView.js";
 
 export default class extends AbstractView {
     constructor(params) {
@@ -16,4 +16,4 @@ export default class extends AbstractView {
             </p>
         `;
     }
-}
+}

frontend/static/js/views/Game.js

@@ -0,0 +1,250 @@
+import AbstractView from "./abstracts/AbstractView.js";
+
+export default class extends AbstractView {
+	constructor(params) {
+		super(params, 'Game');
+		this.game = null;
+	}
+
+	async getHtml() {
+		return `
+			<h1>Game</h1>
+			<button id='startGameButton'>Start Game</button>
+			<button id='stopGameButton'>Stop Game</button>
+		`;
+	}
+
+	async postInit() {
+		document.getElementById('startGameButton').onclick = this.startGame.bind(this);
+		document.getElementById('stopGameButton').onclick = this.stopGame.bind(this);
+	}
+
+	startGame() {
+		if (this.game == null) {
+			document.getElementById('startGameButton').innerHTML = 'Reset Game';
+			this.game = new Game;
+		}
+		else {
+			document.getElementById('app').removeChild(this.game.canvas);
+			this.game.cleanup();
+			this.game = new Game;
+		}
+	}
+
+	stopGame() {
+		if (!this.game)
+			return;
+		document.getElementById('app').removeChild(this.game.canvas);
+		document.getElementById('app').removeChild(this.game.scoresDisplay);
+		this.game.cleanup();
+		this.game = null;
+		document.getElementById('startGameButton').innerHTML = 'Start Game';
+	}
+}
+
+class Game {
+	constructor() {
+		//Global variables
+		this.def = {
+			CANVASHEIGHT: 270,
+			CANVASWIDTH: 480,
+			PADDLEHEIGHT: 70,
+			PADDLEWIDTH: 10,
+			PADDLEMARGIN: 5,
+			PADDLESPEED: 3,
+			BALLRADIUS: 5,
+			BALLSPEED: 2,
+			BALLSPEEDINCR: 0.15,
+			MAXBOUNCEANGLE: 10 * (Math.PI / 12),
+			MAXSCORE: 6
+		};
+
+		this.canvas = document.createElement('canvas');
+		this.canvas.id = 'gameCanvas';
+		this.canvas.width = this.def.CANVASWIDTH;
+		this.canvas.height = this.def.CANVASHEIGHT;
+		this.canvas.style.border = '1px solid #d3d3d3';
+		this.canvas.style.backgroundColor = '#f1f1f1';
+		this.context = this.canvas.getContext('2d');
+		document.getElementById('app').appendChild(this.canvas);
+		this.scoresDisplay = document.createElement('p');
+		this.scoresDisplay.innerHTML = 'Scores: 0 - 0';
+		document.getElementById('app').appendChild(this.scoresDisplay);
+
+		this.players = [
+			{
+				paddle: new Paddle(this.context,
+							this.def.PADDLEMARGIN,
+							this.def),
+				score: 0
+			},
+			{
+				paddle: new Paddle(this.context,
+							this.def.CANVASWIDTH - this.def.PADDLEMARGIN - this.def.PADDLEWIDTH,
+							this.def),
+				score: 0
+			}
+		];
+		this.ballStartSide = 0;
+		this.ballRespawned = false;
+		this.ball = new Ball(this.context, this.def, this.ballStartSide);
+
+		this.interval = setInterval(this.updateGame.bind(this), 10);
+
+		this.keys = [];
+		this.keyUpHandler = this.keyUpHandler.bind(this);
+		this.keyDownHandler = this.keyDownHandler.bind(this);
+		document.addEventListener('keydown', this.keyDownHandler);
+		document.addEventListener('keyup', this.keyUpHandler);
+	}
+
+	cleanup() {
+		clearInterval(this.interval);
+		document.removeEventListener('keydown', this.keyDownHandler);
+		document.removeEventListener('keyup', this.keyUpHandler);
+		this.canvas.style.display = 'none';
+	}
+
+	clear() {
+		this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
+	}
+
+	updateGame() {
+		//Paddle movement
+		if (this.keys.includes('s') &&
+			this.players[0].paddle.y + this.def.PADDLEHEIGHT < this.def.CANVASHEIGHT - this.def.PADDLEMARGIN)
+				this.players[0].paddle.y += this.def.PADDLESPEED;
+		if (this.keys.includes('w') &&
+			this.players[0].paddle.y > 0 + this.def.PADDLEMARGIN)
+				this.players[0].paddle.y -= this.def.PADDLESPEED;
+
+		if (this.keys.includes('ArrowDown') &&
+			this.players[1].paddle.y + this.def.PADDLEHEIGHT < this.def.CANVASHEIGHT - this.def.PADDLEMARGIN)
+				this.players[1].paddle.y += this.def.PADDLESPEED;
+		if (this.keys.includes('ArrowUp') &&
+			this.players[1].paddle.y > 0 + this.def.PADDLEMARGIN)
+				this.players[1].paddle.y -= this.def.PADDLESPEED;
+
+		//GOOAAAAL
+		if (this.ball.x <= 0)
+			this.updateScore(this.players[0].score, ++this.players[1].score);
+		else if (this.ball.x >= this.def.CANVASWIDTH)
+			this.updateScore(++this.players[0].score, this.players[1].score);
+
+		//Ball collisions
+		if (this.detectCollision(this.players[0].paddle, this.ball))
+			this.calculateBallVelocity(this.players[0].paddle.getCenter().y, this.ball);
+		else if (this.detectCollision(this.players[1].paddle, this.ball))
+			this.calculateBallVelocity(this.players[1].paddle.getCenter().y, this.ball, -1);
+
+		if (this.ball.y - this.ball.radius <= 0)
+			this.ball.vy *= -1;
+		else if (this.ball.y + this.ball.radius >= this.canvas.height)
+			this.ball.vy *= -1;
+
+		if (!this.ballRespawned) {
+			this.ball.x += this.ball.vx;
+			this.ball.y += this.ball.vy;
+		}
+
+		this.clear();
+		this.players[0].paddle.update();
+		this.players[1].paddle.update();
+		this.ball.update();
+	}
+
+	updateScore(p1Score, p2Score) {
+		if (p1Score > this.def.MAXSCORE) {
+			this.scoresDisplay.innerHTML = 'Player 1 wins!! GGS';
+			this.cleanup();
+		}
+		else if (p2Score > this.def.MAXSCORE) {
+			this.scoresDisplay.innerHTML = 'Player 2 wins!! GGS';
+			this.cleanup();
+		} else {
+			this.scoresDisplay.innerHTML = `Scores: ${p1Score} - ${p2Score}`;
+			this.ballStartSide = 1 - this.ballStartSide;
+			this.ball = new Ball(this.context, this.def, this.ballStartSide);
+			this.ballRespawned = true;
+			new Promise(r => setTimeout(r, 300))
+				.then(_ => this.ballRespawned = false);
+		}
+	}
+
+	detectCollision(paddle, ball) {
+		let paddleCenter = paddle.getCenter();
+		let dx = Math.abs(ball.x - paddleCenter.x);
+		let dy = Math.abs(ball.y - paddleCenter.y);
+		if (dx <= ball.radius + paddle.width / 2 &&
+			dy <= ball.radius + paddle.height / 2)
+				return true;
+		return false;
+	}
+
+	calculateBallVelocity(paddleCenterY, ball, side = 1) {
+		let relativeIntersectY = paddleCenterY - ball.y;
+		let normRelIntersectY = relativeIntersectY / this.def.PADDLEHEIGHT / 2;
+		let bounceAngle = normRelIntersectY * this.def.MAXBOUNCEANGLE;
+
+		ball.speed += this.def.BALLSPEEDINCR;
+		ball.vx = ball.speed * side * Math.cos(bounceAngle);
+		ball.vy = ball.speed * -Math.sin(bounceAngle);
+	}
+
+	keyUpHandler(ev) {
+		const idx = this.keys.indexOf(ev.key);
+		if (idx != -1)
+			this.keys.splice(idx, 1);
+	}
+
+	keyDownHandler(ev) {
+		if (!this.keys.includes(ev.key))
+			this.keys.push(ev.key);
+	}
+}
+
+class Paddle {
+	constructor(context, paddleSide, def) {
+		this.width = def.PADDLEWIDTH;
+		this.height = def.PADDLEHEIGHT;
+		this.x = paddleSide;
+		this.y = def.CANVASHEIGHT / 2 - this.height / 2;
+		this.ctx = context;
+		this.update();
+	}
+
+	update() {
+		this.ctx.fillStyle = 'black';
+		this.ctx.fillRect(this.x, this.y, this.width, this.height);
+	}
+
+	getCenter() {
+		return {
+			x: this.x + this.width / 2,
+			y: this.y + this.height / 2
+		};
+	}
+}
+
+class Ball {
+	constructor(context, def, startSide) {
+		this.radius = def.BALLRADIUS;
+		this.speed = def.BALLSPEED;
+		this.x = def.CANVASWIDTH / 2;
+		this.y = def.CANVASHEIGHT / 2;
+		this.vy = 0;
+		if (startSide === 0)
+			this.vx = -this.speed;
+		else
+			this.vx = this.speed;
+		this.ctx = context;
+		this.update();
+	}
+
+	update() {
+		this.ctx.fillStyle = 'black';
+		this.ctx.beginPath();
+		this.ctx.arc(this.x, this.y, this.radius, 0, 2 * Math.PI);
+		this.ctx.fill();
+	}
+}

frontend/static/js/views/HomeView.js

@@ -1,4 +1,4 @@
-import AbstractAuthentificateView from "./AbstractAuthentifiedView.js";
+import AbstractAuthentificateView from "./abstracts/AbstractAuthentifiedView.js";
 
 export default class extends AbstractAuthentificateView {
     constructor(params) {
@@ -9,8 +9,10 @@ export default class extends AbstractAuthentificateView {
     async getHtml() {
         return `
 			<h1>HOME</h1>
+            <a href="/matchmaking" class="nav__link" data-link>Play a game</a>
+            <a href="/game/offline" class="nav__link" data-link>Play offline</a>
             <a href="/me" class="nav__link" data-link>Me</a>
             <a href="/logout" class="nav__link" data-link>Logout</a>
         `;
     }
-}
+}

frontend/static/js/views/MatchMakingView.js

@@ -0,0 +1,29 @@
+import { client, navigateTo } from "../index.js";
+import AbstractView from "./abstracts/AbstractView.js";
+
+function game_found(game_id)
+{
+    navigateTo(`/games/${game_id}`)
+}
+
+export default class extends AbstractView {
+    constructor(params) {
+        super(params, "Dashboard");
+    }
+
+    async postInit()
+    {
+        await client.matchmaking.start(game_found)
+    }
+
+    async getHtml() {
+        return `
+			<h1>finding<h1>
+        `;
+    }
+
+    async leavePage()
+    {
+		await client.matchmaking.stop();
+    }
+}

frontend/static/js/views/MeView.js

@@ -1,5 +1,6 @@
 import { client, navigateTo } from "../index.js";
-import AbstractAuthentificateView from "./AbstractAuthentifiedView.js";
+import { clear, fill_errors } from "../utils/formUtils.js";
+import AbstractAuthentificateView from "./abstracts/AbstractAuthentifiedView.js";
 
 export default class extends AbstractAuthentificateView
 {    
@@ -10,63 +11,39 @@ export default class extends AbstractAuthentificateView
 
     async postInit()
     {
-        if (this.fill() === null)
+        document.getElementById("save-account-button").onclick = this.save_account;
-            return;
+        document.getElementById("delete-account-button").onclick = this.delete_account;
-        document.getElementById("save-button").onclick = this.save;
+        document.getElementById("save-profile-button").onclick = this.save_profile;
-        document.getElementById("delete-button").onclick = this.delete_accounts;
     }
 
-    async fill()
+    async delete_account()
     {
-        let data = await client.account.get();
+        let current_password = document.getElementById("current_password-input").value;
-    
-        if (data === null)
-        {
-            navigateTo("/login")
-            return;
-        }
-        document.getElementById("username").value = data.username;
-    }
-
-    async delete_accounts()
-    {
-        let current_password = document.getElementById("current_password").value;
         
         let response_data = await client.account.delete(current_password);
 
-        if (response_data === null)
+        console.log(await client.isAuthentificate())
+        if (response_data === null || response_data === "user deleted")
         {
             navigateTo("/login");
             return;
         }
-
+        clear("innerHTML", ["current_password-input"])
-        ["delete", "current_password"].forEach(error_field => {
+        fill_errors({"current_password-input": response_data["password"]}, "innerHTML")
-            let error_display = document.getElementById(`error_${error_field}`);
-            if (error_display != null)
-                error_display.innerHTML = "";
-        });
-
-        if (response_data === "user deleted")
-        {
-            document.getElementById(`error_delete`).innerHTML = "OK";
-            navigateTo("/login")
-            return;
-        }
-
-        document.getElementById("error_current_password").innerHTML = response_data["password"]
     }
 
-    async save()
+    async save_account()
     {
-        let username = document.getElementById("username").value;
+        let username = document.getElementById("username-input").value;
-        let new_password = document.getElementById("new_password").value;
+        let new_password = document.getElementById("new_password-input").value;
-        let current_password = document.getElementById("current_password").value;
+        let current_password = document.getElementById("current_password-input").value;
     
         let data = {};
     
         data.username = username;
         if (new_password.length != 0)
             data.new_password = new_password;
+
         let response_data = await client.account.update(data, current_password);
 
         if (response_data === null)
@@ -74,53 +51,55 @@ export default class extends AbstractAuthentificateView
             navigateTo("/login");
             return;
         }
-        else if (response_data === "data has been alterate")
+
-        {
+        if (response_data === "data has been alterate")
-            navigateTo("/me");
+            response_data = {"save-account": "saved"}
-            return; 
+
-        }
+        clear("innerHTML", ["username", "new_password", "current_password", "save-account", "delete-account"])
+        fill_errors(response_data, "innerHTML")
+    }
     
-        ["username", "new_password", "current_password"].forEach(error_field => {
+    async save_profile()
-            let error_display = document.getElementById(`error_${error_field}`);
+    {
-            if (error_display != null)
+        let avatar = document.getElementById("avatar-input");
-                error_display.innerHTML = "";
-        });
-    
-        Object.keys(response_data).forEach(error_field => {
-            let error_display = document.getElementById(`error_${error_field}`);
-            if (error_display != null)
-                error_display.innerHTML = response_data[error_field];
-        });
-        let avatar = document.getElementById("avatar");
 
         if (avatar.files[0] !== undefined)
         {
             let form_data = new FormData();
             form_data.append("file", avatar.files[0]);
-            await client.me.change_avatar(form_data)
+            await client.me.change_avatar(form_data);
         }
+        document.getElementById("save-profile").innerHTML = "Saved";
     }
-    
+
     async getHtml()
     {
         return `
+            <link rel="stylesheet" href="/static/css/me.css">
 			<h1>ME</h1>
-            <div class="accounts">
+            <div id="main">
-                <input type="text" placeholder="username" id="username">
+                <div class="account">
-                <span id="error_username"></span>
+                    <h3>Account</h3>
-                <input type=password placeholder="new password" id="new_password">
+                    <input type="text" placeholder="username" id="username-input" text=${client.me.username}>
-                <span id="error_new_password"></span>
+                    <span id="username"></span>
-                <input type=password placeholder="current password" id="current_password">
+                    <input type=password placeholder="new_password" id="new_password-input">
-                <span id="error_current_password"></span>
+                    <span id="new_password"></span>
+                    <input type=password placeholder="current_password" id="current_password-input">
+                    <span id="current_password"></span>
+
+                    <input type="button" value="Save Credentials" id="save-account-button">
+                    <span id="save-account"></span>
+                    <input type="button" value="Delete Account" id="delete-account-button">
+                    <span id="delete-account"></span>
+                </div>
+                <div class="profile">
+                    <h3>Profile</h3>
+                    <input type="file" id="avatar-input" accept="image/png, image/jpeg">
+                    <input type="button" value="Save profile" id="save-profile-button">
+                    <span id="save-profile"></span>
+                </div>
+                <a href="/logout" class="nav__link" data-link>Logout</a>
             </div>
-            <div class="profile">
-                <input type="file" placeholder="username" id="avatar" accept="image/png, image/jpeg">
-            </div>
-            <input type="button" value="Save" id="save-button">
-            <span id="error_save"></span>
-            <input type="button" value="Delete" id="delete-button">
-            <span id="error_delete"></span>
-            <a href="/logout" class="nav__link" data-link>Logout</a>
         `;
     }
-}
+}

frontend/static/js/views/PageNotFoundView.js

@@ -0,0 +1,14 @@
+import AbstractView from "./abstracts/AbstractView.js";
+
+export default class extends AbstractView {
+    constructor(params) {
+        super(params, "Dashboard");
+    }
+
+	async getHtml() {
+		return `
+			<h1>404 Bozo</h1>
+			<p>Git gud</p>
+		`;
+	}
+}

frontend/static/js/views/ProfilePageView.js

@@ -0,0 +1,62 @@
+import AbstractView from "./abstracts/AbstractView.js";
+import { client } from "../index.js"
+
+export default class extends AbstractView {
+    constructor(params) {
+        super(params, "Profile ");
+        this.user_id = params.id;
+    }
+
+    async postInit()
+    {
+        this.profile = await client.profiles.getProfile(this.user_id);
+		this.info = document.getElementById("info");
+
+		// Username
+        let username = document.createElement("a");
+		username.id = "username";
+        username.appendChild(document.createTextNode(this.profile.username));
+		this.info.appendChild(username);
+
+		this.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() {
+		// 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);
+		}
+	}
+
+    async getHtml() {
+        return `
+            <link rel="stylesheet" href="/static/css/profile.css">
+			<div id="info"> 
+
+			</div>
+        `;
+    }
+}

frontend/static/js/views/Search.js

@@ -1,38 +1,227 @@
-import AbstractAuthentifiedView from "./AbstractAuthentifiedView.js";
+import AbstractView from "./abstracts/AbstractView.js";
+import {client} from "../index.js";
+import {Message} from "../api/chat/message.js"
 
-export default class extends AbstractAuthentifiedView {
+export default class extends AbstractView {
     constructor(params) {
         super(params, "Search");
     }
 
 	async postInit() {
-		let users = ["cramptéMan", "cacaMan", "chatteWomen"]
 
+		let search = document.getElementById("input_user");
+		search.oninput = this.users;
+
+		let chat_input = document.getElementById("input_chat");
+		//chat_input.addEventListener("keydown", this.chat_manager)
+
+		this.last_add_chat = undefined;
+		this.users();
+		this.chat();
+
+	}
+
+	async users() {
+
+		let search = document.getElementById("input_user").value.toLowerCase();
+		
+		let logged = await client.isAuthentificate();
+
+		let users = await client.profiles.all();
 		let list_users = document.getElementById('list_users');
-		for (const user of users) {
+		list_users.innerHTML = "";
+
+		users.filter(user => user.username.toLowerCase().startsWith(search) == true).forEach((user) => {
+
+			if (user.user_id == null) {
+				console.log("list User one with id null;");
+				return;
+			}
+
 			var new_user = document.createElement("li");
-			new_user.appendChild(document.createTextNode(user));
+
+			// username
+			let username = document.createElement("a");
+			username.href = `/profiles/${user.user_id}`;
+			username.appendChild(document.createTextNode(user.username));
+			new_user.appendChild(username);
+
+			// space
+			new_user.appendChild(document.createTextNode(" "));
+
+			// chat
+			if (logged && client.me.user_id != user.user_id) {
+				let add_chat = document.createElement("a");
+				add_chat.id = "add_chat_off";
+				add_chat.onclick = async () => {
+					if (client.channel != undefined) {
+						client.channel.members_id.forEach((member_id) => {
+							if (member_id == user.user_id)
+								client.channel = undefined;
+						});
+
+						if (client.channel == undefined) {
+							add_chat.id = "add_chat_off";
+							this.last_add_chat = undefined;
+							return this.hideChat();
+						}
+
+						client.channel.disconnect();
+					}
+
+					client.channel = await client.channels.createChannel([client.me.user_id , user.user_id], this.chat);
+					this.chat();
+					if (this.last_add_chat != undefined)
+						this.last_add_chat.id = "add_chat_off";
+					this.last_add_chat = add_chat;
+					add_chat.id = "add_chat_on";
+				};
+				add_chat.appendChild(document.createTextNode("Chat"));
+				new_user.appendChild(add_chat);
+				
+				new_user.appendChild(document.createTextNode(" "));
+
+			}
+			
+			// break line
+			new_user.appendChild(document.createElement("br"));
+
+			// avatar
+			var img = document.createElement("img");
+			img.src = user.avatar_url;
+			new_user.appendChild(img);
+
+
 			list_users.appendChild(new_user);
+		});
+		//console.log(list_users);
+
+	}
+
+	async chat() {
+
+		let users = await client.profiles.all();
+		let logged = await client.isAuthentificate();
+		/*let reload = document.getElementById("messages");
+		if (reload != null)
+			reload.remove();*/
+
+		let reload = document.getElementById("members");
+		if (reload != null)
+			reload.remove();
+
+		if (client.channel == undefined || !logged)
+			return ;
+
+		let chats = document.getElementById("chats");
+
+		if (document.getElementById("chat") == null) {
+			let chat = document.createElement("div");
+			chat.id = "chat";
+			chats.appendChild(chat);
 		}
-		console.log(list_users);
+
+		
+		// div des messages
+		let messages = document.getElementById("messages");
+		if (messages == null) {
+			messages = document.createElement("div");
+			messages.id = "messages";
+			if (document.getElementById("input_chat") == null)
+				chat.appendChild(messages);
+			else
+				document.getElementById("input_chat").before(messages);
+		}
+
+		// 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) {
+				let text = document.createElement("p");
+				text.appendChild(document.createTextNode(message.content));
+				if (message.author_id == client.me.user_id)
+					text.id = "you";
+				else
+					text.id = "other";
+
+				messages.appendChild(text);
+			}
+			i++;
+		});
+
+		// Input pour rentrer un message
+		if (document.getElementById("input_chat") == null) {
+			let chat_input = document.createElement("input");
+			chat_input.id="input_chat";
+			chat_input.type="text";
+			chat_input.name="message";
+			chat_input.placeholder="message bozo";
+			chat_input.maxLength=255;
+			chat.appendChild(chat_input);
+			
+			chat_input.onkeydown = 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)
+
+					// Reset
+					chat_input.value = "";
+				}
+			};
+		}
+
+		// nom des membres du chat
+		let members = document.createElement("h2");
+		members.id = "members";
+		let usernames = "";
+		client.channel.members_id.forEach((member_id) => {
+			if (member_id != client.me.user_id) {
+				if (usernames.length > 0)
+					usernames += ", ";
+				usernames += (users.filter(user => user.user_id == member_id)[0].username);
+			}
+		});
+		members.appendChild(document.createTextNode(usernames));
+		messages.before(members);
+
+
+		// Scroll to the bottom of messages
+		messages.scrollTop = messages.scrollHeight;
+
+	}
+
+	async hideChat() {
+
+		let close = document.getElementById("chat");
+		if (close != null)
+			close.remove();
+
 	}
 
 	async leavePage() {
+		if (client.channel != undefined)
+			client.channel.disconnect();
+		client.channel = undefined
 	}
 
     async getHtml() {
         return `
-			<h1>Search</h1>
+			<link rel="stylesheet" href="/static/css/search.css">
 
-			<form id="form">
+			<div id="chats">
-				<input type="text" name="message" placeholder="user name to crampte"/>
+				<div id="users">
-			</form>
+					<input id="input_user" type="text" name="message" placeholder="userbozo"/>
-
+					<ul id="list_users">
-			<div id="users">
+					</ul>
-				<ul id="list_users">
+				</div>
-				</ul>
 			</div>
-
         `;
     }
 }

frontend/static/js/views/Settings.js

@@ -1,14 +0,0 @@
-import AbstractView from "./AbstractView.js";
-
-export default class extends AbstractView {
-    constructor(params) {
-        super(params, "Settings");
-    }
-
-    async getHtml() {
-        return `
-            <h1>Settings</h1>
-            <p>Manage your privacy and configuration.</p>
-        `;
-    }
-}

frontend/static/js/views/abstracts/AbstractAuthentifiedView.js

@@ -1,4 +1,4 @@
-import { client, navigateTo } from "../index.js";
+import { client, navigateTo } from "../../index.js";
 import AbstractRedirectView from "./AbstractRedirectView.js";
 
 export default class extends AbstractRedirectView{

frontend/static/js/views/abstracts/AbstractNonAuthentified.js

@@ -1,4 +1,4 @@
-import { client, navigateTo } from "../index.js";
+import { client, navigateTo } from "../../index.js";
 import AbstractRedirectView from "./AbstractRedirectView.js";
 
 export default class extends AbstractRedirectView{

frontend/static/js/views/abstracts/AbstractRedirectView.js

@@ -1,4 +1,4 @@
-import { navigateTo } from "../index.js";
+import { navigateTo } from "../../index.js";
 import AbstractView from "./AbstractView.js";
 
 export default class extends AbstractView{

frontend/static/js/views/accounts/LoginView.js

@@ -1,10 +1,11 @@
 import { client, navigateTo } from "../../index.js";
-import AbstractNonAuthentifiedView from "../AbstractNonAuthentified.js";
+import { clear, fill_errors } from "../../utils/formUtils.js";
+import AbstractNonAuthentifiedView from "../abstracts/AbstractNonAuthentified.js";
 
 async function login()
 {
-	let username = document.getElementById("username").value;
+	let username = document.getElementById("username-input").value;
-	let password = document.getElementById("password").value;
+	let password = document.getElementById("password-input").value;
 	
 	let response_data = await client.login(username, password);
 
@@ -14,17 +15,8 @@ async function login()
 		return;
 	}
 
-	["username", "user", "password"].forEach(error_field => {
+	clear("innerHTML", ["username", "user", "password"]);
-		let error_display = document.getElementById(`error_${error_field}`);
+	fill_errors(response_data, "innerHTML");
-		if (error_display != null)
-			error_display.innerHTML = "";
-	});
-
-	Object.keys(response_data).forEach(error_field => {
-		let error_display = document.getElementById(`error_${error_field}`);
-		if (error_display != null)
-			error_display.innerHTML = response_data[error_field];
-	});
 }
 
 export default class extends AbstractNonAuthentifiedView {
@@ -34,22 +26,22 @@ export default class extends AbstractNonAuthentifiedView {
 
 	async postInit()
 	{
-		document.getElementById("button").onclick = login;
+		document.getElementById("login-button").onclick = login;
 	}
 
     async getHtml() {
         return `
 			<div class=form>
 				<label>Login</label>
-				<link rel="stylesheet" href="static/css/accounts/login.css">
+				<link rel="stylesheet" href="/static/css/accounts/login.css">
-				<input type="text" id="username" placeholder="username">
+				<input type="text" id="username-input" placeholder="username">
-				<span id="error_username"></span>
+				<span id="username"></span>
-				<input type="password" id="password" placeholder="password">
+				<input type="password" id="password-input" placeholder="password">
-				<span id="error_password"></span>
+				<span id="password"></span>
-				<input type="button" value="login" id="button">
+				<input type="button" value="Login" id="login-button">
-				<span id="error_user"></span>
+				<span id="user"></span>
 				<a href="/register" class="nav__link" data-link>Register</a>
 			</div>
         `;
     }
-}
+}

frontend/static/js/views/accounts/LogoutView.js

@@ -1,5 +1,5 @@
 import { client, navigateTo } from "../../index.js";
-import AbstractAuthentifiedView from "../AbstractAuthentifiedView.js";
+import AbstractAuthentifiedView from "../abstracts/AbstractAuthentifiedView.js";
 
 export default class extends AbstractAuthentifiedView
 {
@@ -8,4 +8,4 @@ export default class extends AbstractAuthentifiedView
 		client.logout();
 		navigateTo("/login")
 	}
-}
+}

frontend/static/js/views/accounts/RegisterView.js

@@ -1,10 +1,11 @@
 import { client, navigateTo } from "../../index.js";
-import AbstractNonAuthentifiedView from "../AbstractNonAuthentified.js";
+import { clear, fill_errors } from "../../utils/formUtils.js";
+import AbstractNonAuthentifiedView from "../abstracts/AbstractNonAuthentified.js";
 
 async function register()
 {
-	let username = document.getElementById("username").value;
+	let username = document.getElementById("username-input").value;
-	let password = document.getElementById("password").value;
+	let password = document.getElementById("password-input").value;
 	
 	let response_data = await client.account.create(username, password);
 
@@ -14,17 +15,8 @@ async function register()
 		return;
 	}
 
-	["username", "user", "password"].forEach(error_field => {
+	clear("innerHTML", ["username", "user", "password"]);
-		let error_display = document.getElementById(`error_${error_field}`);
+	fill_errors(response_data, "innerHTML");
-		if (error_display != null)
-			error_display.innerHTML = "";
-	});
-
-	Object.keys(response_data).forEach(error_field => {
-		let error_display = document.getElementById(`error_${error_field}`);
-		if (error_display != null)
-			error_display.innerHTML = response_data[error_field];
-	});
 }
 
 export default class extends AbstractNonAuthentifiedView {
@@ -34,20 +26,20 @@ export default class extends AbstractNonAuthentifiedView {
 
 	async postInit()
 	{
-		document.getElementById("button").onclick = register;
+		document.getElementById("register-button").onclick = register;
 	}
 
     async getHtml() {
         return `
 			<div class=form>
 				<label>Register</label>
-				<link rel="stylesheet" href="static/css/accounts/register.css">
+				<link rel="stylesheet" href="/static/css/accounts/register.css">
-				<input type="text" id="username" placeholder="username">
+				<input type="text" id="username-input" placeholder="username">
-				<span id="error_username"></span>
+				<span id="username"></span>
-				<input type="password" id="password" placeholder="password">
+				<input type="password" id="password-input" placeholder="password">
-				<span id="error_password"></span>
+				<span id="password"></span>
-				<input type="button" value="register" id="button">
+				<input type="button" value="Register" id="register-button">
-				<span id="error_user"></span>
+				<span id="user"></span>
 				<a href="/login" class="nav__link" data-link>Login</a>
 			</div>
         `;

frontend/static/js/views/profiles/ProfilePageView.js

@@ -1,29 +0,0 @@
-import AbstractView from "../AbstractView.js";
-import { client } from "../../index.js"
-
-export default class extends AbstractView {
-    constructor(params) {
-        super(params, "Profile ");
-        this.user_id = params.id;
-    }
-
-    async postInit()
-    {
-        let profile = await client.profiles.getProfile(this.user_id);
-
-        let username_element = document.getElementById("username");
-        username_element.href = `/profiles/${this.user_id}`;
-        username_element.appendChild(document.createTextNode(profile.username));
-
-        let avatar_element = document.getElementById("avatar");
-        avatar_element.src = profile.avatar_url;
-    }
-
-    async getHtml() {
-        return `
-            <link rel="stylesheet" href="/static/css/profiles/profile.css">
-		    <img id="avatar"/>
-		    <a id="username"></a>
-        `;
-    }
-}

frontend/static/js/views/profiles/ProfilesView.js

@@ -1,40 +0,0 @@
-import AbstractView from "../AbstractView.js";
-import { client } from "../../index.js"
-
-export default class extends AbstractView {
-    constructor(params) {
-        super(params, "Profiles");
-    }
-
-    async postInit()
-    {
-        let profiles = await client.profiles.all()
-		let profile_list_element = document.getElementById("profile-list")
-
-		profiles.forEach((profile) => {
-			let profile_element = document.createElement("div");
-			profile_element.className = "item";
-			
-			let avatar = document.createElement("img");
-			avatar.src = profile.avatar_url;
-
-			let username = document.createElement("a");
-			username.href = `/profiles/${profile.user_id}`;
-			username.appendChild(document.createTextNode(profile.username));
-
-			profile_element.appendChild(avatar);
-			profile_element.appendChild(username);
-
-			profile_list_element.appendChild(profile_element)
-		});
-    }
-
-    async getHtml() {
-        return `
-			<link rel="stylesheet" href="/static/css/profiles/profiles.css">
-		    <div id="profile-list">
-			
-			</div>
-        `;
-    }
-}

frontend/templates/index.html

@@ -10,10 +10,10 @@
 <body>
     <nav class="nav">
         <a href="/" class="nav__link" data-link>Dashboard</a>
-        <a href="/profiles" class="nav__link" data-link>Profiles</a>
+        <a href="/search" class="nav__link" data-link>Search</a>
+        <a href="/home" class="nav__link" data-link>Home</a>
         <a href="/login" class="nav__link" data-link>Login</a>
         <a href="/register" class="nav__link" data-link>Register</a>
-        <a href="/search" class="nav__link" data-link>Search</a>
     </nav>
     <div id="app"></div>
 	<script type="module" src="{% static 'js/index.js' %}"></script>

games/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

games/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class GamesConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'games'

games/models.py

@@ -0,0 +1,14 @@
+from django.db import models
+
+# Create your models here.
+class GameModel(models.Model):
+	
+	def create(self, users_id: [int]):
+		self.save()
+		for user_id in users_id:
+			GameMembersModel(game_id=self.pk, member_id=user_id)
+		return self.pk
+
+class GameMembersModel(models.Model):
+	game_id = models.IntegerField()
+	member_id = models.IntegerField()

games/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

games/views.py

@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.

matchmaking/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

matchmaking/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class MatchmakingConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'matchmaking'

matchmaking/consumers.py

@@ -0,0 +1,48 @@
+from channels.generic.websocket import WebsocketConsumer
+
+from django.contrib.auth.models import User
+
+from games.models import GameModel
+
+import json
+
+queue_id: [int] = []
+queue_ws: [WebsocketConsumer] = []
+
+class MatchMaking(WebsocketConsumer):
+
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+		self.channel_name = "matchmaking"
+		self.group_name = "matchmaking"
+
+	def connect(self):
+
+		user: User = self.scope["user"]
+		if (user.is_anonymous or not user.is_authenticated):
+			return
+
+		self.channel_layer.group_add(self.group_name, self.channel_name)
+
+		self.accept()
+
+		global queue_id, queue_ws
+		queue_id.append(user.pk)
+		queue_ws.append(self)
+
+		if len(set(queue_id)) == 2:
+			game_id: int = GameModel().create(set(queue_id))
+			event = {"game_id": game_id}
+			for ws in queue_ws:
+				ws.send(text_data=json.dumps({'game_id': game_id}))
+			queue_id.clear()
+			queue_ws.clear()
+
+		
+	def disconnect(self, close_code):
+		user: User = self.scope["user"]
+		global queue_id, queue_ws
+		if (user.pk in queue_id):
+			queue_ws.pop(queue_id.index(user.pk))
+			queue_id.remove(user.pk)
+		self.channel_layer.group_discard(self.group_name, self.channel_name)

matchmaking/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

matchmaking/routing.py

@@ -0,0 +1,6 @@
+from django.urls import re_path
+from . import consumers
+
+websocket_urlpatterns = [
+	re_path(r'ws/matchmaking/', consumers.MatchMaking.as_asgi())
+]

matchmaking/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

matchmaking/views.py

@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.

profiles/admin.py

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

profiles/models.py

@@ -4,6 +4,7 @@ from django.contrib.auth.models import User
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.conf import settings
+from django.db.models import IntegerField
 
 def upload_to(instance, filename: str):
     return f"./profiles/static/avatars/{instance.pk}.{filename.split('.')[1]}"
@@ -11,10 +12,17 @@ def upload_to(instance, filename: str):
 # Create your models here.
 class ProfileModel(models.Model):
     user = models.ForeignKey(User, on_delete=models.CASCADE)
-    avatar_url = models.ImageField(upload_to=upload_to, default="../static/avatars/default.avif") #blank=True, null=True)
+    avatar_url = models.ImageField(upload_to=upload_to, default="./profiles/static/avatars/default.avif") #blank=True, null=True)
 
 @receiver(post_save, sender=User)
 def on_user_created(sender, instance, created, **kwargs):
     if created:
         profile: ProfileModel = ProfileModel.objects.create(pk = instance.pk, user = instance)
-        profile.save()
+        profile.save()
+		
+class BlockModel(models.Model):
+	blocker = IntegerField(primary_key=False)
+	blocked = IntegerField(primary_key=False)
+
+	def __str__(self):
+		return "blocker_id: " + str(self.blocker) + ", blocked_id: " + str(self.blocked)

profiles/urls.py

@@ -3,9 +3,13 @@ from django.conf import settings
 from django.conf.urls.static import static
 
 from . import viewsets
+from . import views
 
 urlpatterns = [
-    path("<int:pk>", viewsets.ProfileViewSet.as_view({'get': 'retrieve', 'patch': 'partial_update'}), name="profile_page"),
+    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("me", viewsets.ProfileViewSet.as_view(), name="my_profile_page"),
+	path("block", views.BlocksView.as_view(), name="block_page"),
-] + static("/static/avatars/", document_root="./avatars")
+	path("block/<int:pk>", views.BlockView.as_view(), name="block_page"),
+
+] + static("/static/avatars/", document_root="./avatars")

profiles/views.py

@@ -0,0 +1,66 @@
+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 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)
+
+
+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)

profiles/viewsets.py

@@ -3,6 +3,7 @@ from rest_framework.parsers import MultiPartParser, FormParser
 from rest_framework import permissions, status
 from rest_framework import viewsets
 from rest_framework.response import Response
+from rest_framework.authentication import SessionAuthentication
 
 from django.http import HttpRequest
 from django.db.models import QuerySet
@@ -11,19 +12,21 @@ from .serializers import ProfileSerializer
 from .models import ProfileModel
 
 class ProfileViewSet(viewsets.ModelViewSet):
-    queryset = ProfileModel.objects.all()
+    queryset = ProfileModel.objects.all
     serializer_class = ProfileSerializer
     parser_classes = (MultiPartParser, FormParser)
     permission_classes = (permissions.IsAuthenticatedOrReadOnly,)
 
     def retrieve(self, request: HttpRequest, pk=None):
-        instance = self.get_object()
+        if (not self.queryset().filter(pk=pk).exists()):
+            return Response({"detail": "Profile not found."}, status=status.HTTP_404_NOT_FOUND)
+        instance = self.queryset().get(pk=pk)
         instance.avatar_url.name = instance.avatar_url.name[instance.avatar_url.name.find("static") - 1:]
         return Response(self.serializer_class(instance).data,
                         status=status.HTTP_200_OK)
 
     def list(self, request: HttpRequest):
-        serializer = ProfileSerializer(self.queryset, many=True)
+        serializer = ProfileSerializer(self.queryset(), many=True)
         for profile in serializer.data:
             profile["avatar_url"] = profile["avatar_url"][profile["avatar_url"].find("static") - 1:]
         return Response(serializer.data)
@@ -31,14 +34,28 @@ class ProfileViewSet(viewsets.ModelViewSet):
     def perform_create(self, serializer):
         serializer.save(user=self.request.user)
 
-    def perform_update(self, serializer):
+class MyProfileViewSet(viewsets.ModelViewSet):
-        query: QuerySet = ProfileModel.objects.filter(pk=self.request.user.pk)
+
-        if (not query.exists()):
+    permission_classes = (permissions.IsAuthenticated,)
-            return Response("profile not found", status=status.HTTP_400_BAD_REQUEST)
+    authentication_classes = (SessionAuthentication,)
-        profile: ProfileModel = ProfileModel.objects.get(pk=self.request.user.pk)
+    serializer_class = ProfileSerializer
+    queryset = ProfileModel.objects.all
+
+    def get_object(self):
+        obj = self.queryset().get(pk=self.request.user.pk)
+        return obj
+
+    def perform_update(self, serializer, pk=None):
+        profile: ProfileModel = self.get_object()
         avatar = self.request.data.get("file", None)
         if (avatar is not None):
-            if (profile.avatar_url.name != "default.avif"):
+            if (profile.avatar_url.name != "./profiles/static/avatars/default.avif"):
                 profile.avatar_url.storage.delete(profile.avatar_url.name)
             profile.avatar_url = avatar
-        profile.save()
+        profile.save()
+    
+    def retrieve(self, request: HttpRequest, pk=None):
+        instance: ProfileModel = self.get_object()
+        instance.avatar_url.name = instance.avatar_url.name[instance.avatar_url.name.find("static") - 1:]
+        return Response(self.serializer_class(instance).data,
+                        status=status.HTTP_200_OK)

requirements.txt

@@ -1,10 +1,30 @@
 asgiref==3.7.2
+attrs==23.1.0
+autobahn==23.6.2
+Automat==22.10.0
+cffi==1.16.0
+channels==4.0.0
+constantly==23.10.4
+cryptography==41.0.7
+daphne==4.0.0
 Django==4.2.6
 django-cors-headers==4.3.0
 django-restapi==0.1.3
 djangorestframework==3.14.0
+hyperlink==21.0.0
+idna==3.6
+incremental==22.10.0
 install==1.3.5
+Pillow==10.1.0
+pyasn1==0.5.1
+pyasn1-modules==0.3.0
+pycparser==2.21
+pyOpenSSL==23.3.0
 pytz==2023.3.post1
+service-identity==23.1.0
+six==1.16.0
 sqlparse==0.4.4
-channels==4.0.0
+Twisted==23.10.0
-daphne
+txaio==23.1.1
+typing_extensions==4.8.0
+zope.interface==6.1

trancendence/asgi.py

@@ -10,7 +10,9 @@ https://docs.djangoproject.com/en/4.2/howto/deployment/asgi/
 import os
 from channels.routing import ProtocolTypeRouter, URLRouter
 from channels.auth import AuthMiddlewareStack
+
 import chat.routing
+import matchmaking.routing
 
 from django.core.asgi import get_asgi_application
 
@@ -20,7 +22,8 @@ application = ProtocolTypeRouter({
     'http':get_asgi_application(),
 	'websocket':AuthMiddlewareStack(
 		URLRouter(
-			chat.routing.websocket_urlpatterns
+			chat.routing.websocket_urlpatterns +
+			matchmaking.routing.websocket_urlpatterns
 		)
 	)
 })

trancendence/settings.py

@@ -43,9 +43,12 @@ INSTALLED_APPS = [
 	'channels',
 	'daphne',
 
+    'matchmaking.apps.MatchmakingConfig',
+    'games.apps.GamesConfig',
     'accounts.apps.AccountsConfig',
     'profiles.apps.ProfilesConfig',
     'frontend.apps.FrontendConfig',
+    'chat.apps.ChatConfig',
     
     'corsheaders',
     'rest_framework',
@@ -148,4 +151,4 @@ STATIC_URL = 'static/'
 # Default primary key field type
 # https://docs.djangoproject.com/en/4.2/ref/settings/#default-auto-field
 
-DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

trancendence/urls.py

@@ -21,5 +21,6 @@ urlpatterns = [
     path('admin/', admin.site.urls),
     path('api/profiles/', include('profiles.urls')),
     path('api/accounts/', include('accounts.urls')),
+    path('api/chat/', include('chat.urls')),
     path('', include('frontend.urls')),
-]
+]