Block fixed, looking for invite in game

chat/consumersNotice.py

@@ -1,6 +1,8 @@
 from channels.generic.websocket import WebsocketConsumer
 from asgiref.sync import async_to_sync
 
+from games.models import GameModel
+
 import time
 import json
 
@@ -31,19 +33,7 @@ class ChatNoticeConsumer(WebsocketConsumer):
 
 		self.accept()
 
-		message_time: int = int(time.time() * 1000)
+		self.sync()
-		targets = list(self.channel_layer.users_channels.keys())
-		for target in targets:
-			channel = self.channel_layer.users_channels.get(target)
-			if (channel == None or target == user.pk):
-				continue
-			async_to_sync(self.channel_layer.send)(channel, {
-				'type':"online_users",
-				'author_id':user.pk,
-				'targets': targets,
-				'time':message_time,
-				'status': 200,
-			})
 
 	def disconnect(self, code):
 
@@ -51,22 +41,15 @@ class ChatNoticeConsumer(WebsocketConsumer):
 		if (user.is_anonymous or not user.is_authenticated):
 			return	
 
-		self.channel_layer.users_channels.pop(user.pk)
+		del self.channel_layer.users_channels[user.pk]
+		del self.channel_layer.invite[user.pk]
 
-		message_time: int = int(time.time() * 1000)
+		for inviter_id, inviteds_id in self.channel_layer.invite.items():
+			if (user.pk in inviteds_id): 
+				self.channel_layer.invite[inviter_id].remove(user.pk)
+
+		self.sync()
 
-		targets = list(self.channel_layer.users_channels.keys())
-		for target in targets:
-			channel = self.channel_layer.users_channels.get(target)
-			if (channel == None or target == user.pk):
-				continue
-			async_to_sync(self.channel_layer.send)(channel, {
-				'type':"online_users",
-				'author_id':user.pk,
-				'targets': targets,
-				'time':message_time,
-				'status': 200,
-			})
 
 	def receive(self, text_data=None, bytes_data=None):
 
@@ -89,50 +72,115 @@ class ChatNoticeConsumer(WebsocketConsumer):
 		if (self.channel_layer == None):
 			return
 
-		message_time: int = int(time.time() * 1000)
+		message_time: int = int(text_data_json.get('time'))
-		status = 200;
+
+		print(message_time)
+		print(time.time())
+		print(time.time() * 1000 - message_time)
+
+		if (message_time == None):
+			message_time: int = int(time.time() * 1000)
 
 		#print("receive" + str(user.pk))
 
+		result = None
 		try:
-			status = getattr(self, "pre_" + type_notice)(user, targets)
+			status, result = getattr(self, "pre_" + type_notice)(user, targets)
 		except AttributeError:
-			print(f"La fonction pre_{type_notice} n'existe pas.")
+			status = 200
+			#print(f"La fonction pre_{type_notice} n'existe pas.")
 
-		if targets == "all":
+		if (status < 300):
-			targets = list(self.channel_layer.users_channels.keys())
+			if targets == "all":
+				targets = list(self.channel_layer.users_channels.keys())
+
+			for target in targets:
+				channel = self.channel_layer.users_channels.get(target)
+				if (channel == None or target == user.pk):
+					if (channel == None):
+						status = 404
+					continue
+				async_to_sync(self.channel_layer.send)(channel, {
+					'type':type_notice,
+					'author_id':user.pk,
+					'content':content,
+					'result':result,
+					'targets': targets,
+					'time':message_time,
+					'status': 200,
+				})
 
-		for target in targets:
-			channel = self.channel_layer.users_channels.get(target)
-			if (channel == None or target == user.pk):
-				if (channel == None):
-					status = 404
-				continue
-			async_to_sync(self.channel_layer.send)(channel, {
-				'type':type_notice,
-				'author_id':user.pk,
-				'content':content,
-				'targets': targets,
-				'time':message_time,
-				'status': 200,
-			})
 		async_to_sync(self.channel_layer.send)(self.channel_layer.users_channels.get(user.pk), {
 			'type':type_notice,
 			'author_id':user.pk,
-			'content':"notice return",
+			'result':result,
 			'targets': targets,
 			'time':message_time,
 			'status':status,
 		})
 
+	def sync(self, user = None, level = None):
+		
+		sendToUser = True
+		if (user == None):
+			user = self.scope["user"]
+			sendToUser = False
+			
+
+		if (level == None):
+			level = 0
+
+		message_time: int = int(time.time() * 1000)
+		if (sendToUser):
+			targets = [user.pk]
+		else:
+			targets = list(self.channel_layer.users_channels.keys())
+
+		for target in targets:
+			channel = self.channel_layer.users_channels.get(target)
+			if (channel == None or (not sendToUser and target == user.pk)):
+				continue
+			async_to_sync(self.channel_layer.send)(channel, {
+				'type':"online_users",
+				'author_id':user.pk,
+				'targets': targets,
+				'time':message_time,
+				'status': 200,
+			})
+			if (level >= 1): 
+				async_to_sync(self.channel_layer.send)(channel, {
+					'type':"invite",
+					'author_id':user.pk,
+					'targets': targets,
+					'time':message_time,
+					'status': 200,
+				})
+
 
 	def pre_invite(self, user, targets):
-		status = 200
 
+		status = 200
 		for target in targets:
 			if (target in self.channel_layer.invite[user.pk]):
 				status = 409
-		return status
+				continue
+
+			channel = self.channel_layer.users_channels.get(target)
+			if (channel == None):
+				status = 404
+				continue
+
+			# Add the invited in "self.channel_layer.invite"
+			if (user.pk != target):
+				self.channel_layer.invite[user.pk].append(target)
+
+		return status, None
+
+	def get_invites(self, user):
+		invites = []
+		for inviter_id, inviteds_id in self.channel_layer.invite.items():
+			if (user.pk in inviteds_id and user.pk != inviter_id): 
+				invites.append(inviter_id)
 
 	def invite(self, event):
 
@@ -140,23 +188,48 @@ class ChatNoticeConsumer(WebsocketConsumer):
 		if (user.is_anonymous or not user.is_authenticated):
 			return
 
-		if (user.pk in self.channel_layer.invite[event["author_id"]]):
+		invites = self.get_invites(user)
-			return
-
-		if (user.pk != event["author_id"]):
-			self.channel_layer.invite[event["author_id"]].append(user.pk)
 
 		self.send(text_data=json.dumps({
 			'type':event['type'],
 			'author_id':event['author_id'],
-			'content':event['content'],
+			'invites': invites,
 			'targets': event['targets'],
 			'time': event['time'],
 			'status':event['status'],
 		}))
 
-	def pre_online_users(self, user, targets):
+	def pre_accept_invite(self, user, targets):
-		pass
+
+		if (user.pk not in self.channel_layer.invite[targets[0]]):
+			return 400, None
+
+		self.channel_layer.invite[targets[0]].remove(user.pk)
+
+		if (targets[0] in self.channel_layer.invite[user.pk]):
+			self.channel_layer.invite[user.pk].remove(targets[0])
+
+		id_game = GameModel().create([user.pk, targets[0]]);
+
+		return 200, id_game
+
+	def accept_invite(self, event):
+
+		user = self.scope["user"]
+		if (user.is_anonymous or not user.is_authenticated):
+			return
+
+		invites = self.get_invites(user)
+
+		self.send(text_data=json.dumps({
+			'type':event['type'],
+			'author_id':event['author_id'],
+			'result': event['result'],
+			'invites': invites,
+			'time': event['time'],
+			'status':event['status'],
+		}))
+		
 
 	def online_users(self, event):
 

frontend/static/css/search.css

@@ -78,7 +78,6 @@
 	border: none;
 	outline: none;
 	border-bottom: 0.15em solid green;
-	caret-color: green;
 	color: green;
 	font-size: 0.8em;
 }
@@ -106,9 +105,8 @@
 	word-wrap: break-word;
 }
 
-#app #invite {
+#app #invite, #app #yes, #app #no {
 	position: relative;
-	background-color: green;
 	border: none;
 	color: white;
 	text-align: center;
@@ -118,3 +116,15 @@
 	width: 4em;
 	cursor: pointer;
 }
+
+#app #yes, #app #no {
+	position: relative;
+	border: none;
+	color: white;
+	text-align: center;
+	text-decoration: none;
+	font-size: 0.8em;
+	height: 2em;
+	width: 2em;
+	cursor: pointer;
+}

frontend/static/js/api/chat/notice.js

@@ -1,3 +1,4 @@
+import { navigateTo } from "../../index.js";
 import {create_popup} from "../../utils/noticeUtils.js";
 
 class Notice {
@@ -7,9 +8,8 @@ class Notice {
 
 		// users online, invited by, asked friend by, 
 		let data_variable = ["online", "invited", "asked"];
-		for (let i in data_variable) {
+		for (let i in data_variable)
 			this.data[data_variable[i]] = [];
-		}
 
 		this.connect();
 
@@ -20,12 +20,14 @@ class Notice {
 
 		this.chatSocket = new WebSocket(url);
 		this.chatSocket.onmessage = (event) =>{
-			let data = JSON.parse(event.data);
+			let send = JSON.parse(event.data);
-			//console.log("notice: ", data);
+			console.log("notice: ", send);
-			if (data.type == "invite")
+			if (send.type == "invite")
-				this.receiveInvite(data);
+				this.receiveInvite(send);
-			else if (data.type == "online_users" || data.type == "disconnect")
+			else if (send.type == "online_users" || send.type == "disconnect")
-				this.receiveOnlineUser(data);
+				this.receiveOnlineUser(send);
+			else if (send.type == "accept_invite")
+				this.receiveAcceptInvite(send);
 		}
 	    this.chatSocket.onopen = (event) => {
 			this.getOnlineUser();
@@ -40,61 +42,96 @@ class Notice {
 
 	}
 
-	async sendInvite(id_inviter, id_inviteds) {
+	async acceptInvite(invitedBy) {
 
-		if (this.chatSocket == undefined)
+		this.sendRequest({
-			return;
+			type: "accept_invite",
-
+			targets: [invitedBy],
-		this.chatSocket.send(JSON.stringify({
+		});
-			type: "invite",
-			targets: id_inviteds,
-		}));
 
 	}
 
-	async receiveInvite(data) {
+	async receiveAcceptInvite(send) {
 
-		if (data.content === "notice return") {
+		let id_game = send["result"];
-			if (data.status == 200) {
+		navigateTo("/game/" + id_game);
-				for (let target in data.targets)
+
-					this.data["invited"].push(target);
+	}
+
+	async refuseInvite(invitedBy) {
+
+		this.sendRequest({
+			type: "refuse_invite",
+			targets: [invitedBy],
+		});
+
+
+	}
+
+	async sendInvite(id_inviteds) {
+
+		this.sendRequest({
+			type: "invite",
+			targets: id_inviteds,
+			time: new Date().getTime(),
+		});
+
+	}
+
+	async receiveInvite(send) {
+		
+		if (this.client.me == undefined)
+			return ;
+
+		let content = send.content;
+
+		if (send.author_id == this.client.me.id) {
+			if (send.status == 200) {
+				for (let target in send.targets)
 				return create_popup("Invitation send");
 			}
-			else if (data.status == 404)
+			else if (send.status == 404)
 				return create_popup("User not connected");
-			else if (data.status == 409)
+			else if (send.status == 409)
 				return create_popup("Already invited");
 		}
 		else {
-			let sender = await this.client.profiles.getProfile(data.author_id);
 
-			this.inviter.push(data.author_id);
+			if (!content.includes(send.author_id) || 
+				this.data["invited"].includes(send.author_id))
+				return;
+
+			this.data["invited"] = content;
+			let sender = await this.client.profiles.getProfile(send.author_id);
+
 			create_popup("Invitation received by " + sender.username);
 
+			if (this.rewrite_invite !== undefined)
+				this.rewrite_invite();
+
 			// Géré la reception de l'invitation
 		}
 	}
 
 	async getOnlineUser() {
 		
-		if (this.chatSocket == undefined)
-			return;
-
 		this.online_users = {};
 
-		this.chatSocket.send(JSON.stringify({
+		this.sendRequest({
 			type: "online_users",
-			targets: "all",
+			targets: [],
-		}));
+			time: new Date().getTime(),
+		});
 
 	}
 
-	async receiveOnlineUser(data) {
+	async receiveOnlineUser(send) {
-		if (data.content !== undefined) {
+		let content = send.content;
+		if (content !== undefined) {
 
-			if (this.online_users.length > 0) {
+			if (this.data["online"].length > 0) {
 				// get all disconnect user
-				let disconnects = this.online_users.filter(id => !Object.keys(data.content).includes(id));
+				let disconnects = this.data["online"].filter(id => !Object.keys(content).includes(id));
 
 				// delete invite
 				this.data["invited"] = this.data["invited"].filter(id => !disconnects.includes(id));
@@ -102,12 +139,19 @@ class Notice {
 				//console.log(this.data["invited"]);
 			}
 
-			this.data["online"] = Object.keys(data.content);
+			this.data["online"] = Object.keys(content);
 
 			if (this.rewrite_usernames !== undefined)
 				this.rewrite_usernames();
 		}
 	}
+
+	async sendRequest(content) {
+		if (this.chatSocket == undefined)
+			return;
+
+		this.chatSocket.send(JSON.stringify(content));
+	}
 }
 
 export {Notice}

frontend/static/js/api/profile.js

@@ -34,6 +34,7 @@ class Profile
 
 		let block_response = await this.client._get("/api/profiles/block");
 
+
 		if (block_response.status != 200)
 			return
 
@@ -42,7 +43,7 @@ class Profile
 		block_list.forEach(block => {
 		 	let blocker = block.fields.blocker;
 		 	let blocked = block.fields.blocked;
-		 	if (blocker == this.client.me.user_id && blocked == user_id)
+		 	if (blocker == this.client.me.id && blocked == this.id)
 		 		return this.isBlocked = true;
 		});
 	}

frontend/static/js/api/profiles.js

@@ -37,7 +37,7 @@ class Profiles
 
 		// blocker & blocked
 		let response = await this.client._post("/api/profiles/block", { 
-			users_id:[this.client.me.user_id, user_id],
+			users_id:[this.client.me.id, user_id],
 		});
 
 		let data = await response.json();
@@ -49,7 +49,7 @@ class Profiles
 
 		// blocker & blocked
 		let response = await this.client._delete("/api/profiles/block", { 
-			users_id:[this.client.me.user_id, user_id],
+			users_id:[this.client.me.id, user_id],
 		});
 
 		let data = await response.json();

frontend/static/js/views/PageNotFoundView.js

@@ -8,6 +8,7 @@ export default class extends AbstractView {
 	async getHtml() {
 		return `
 			<h1>404 Bozo</h1>
+			<img src="https://media.giphy.com/media/pm0BKtuBFpdM4/giphy.gif">
 			<p>Git gud</p>
 		`;
 	}

frontend/static/js/views/Search.js

@@ -31,9 +31,11 @@ export default class extends AbstractView {
 		//await client.notice.getOnlineUser();
 		await this.wait_get_online_users();
 		client.notice.rewrite_usernames = this.rewrite_usernames;
+		client.notice.rewrite_invite = this.display_invite;
 
 		let search = document.getElementById("input_user");
-		search.oninput = () => this.display_users(logged, profiles);
+		if (search != undefined)
+			search.oninput = () => this.display_users(logged, profiles);
 
 		let chat_input = document.getElementById("input_chat");
 		//chat_input.addEventListener("keydown", this.display_chat_manager)
@@ -175,13 +177,15 @@ export default class extends AbstractView {
 		chat_input.maxLength=255;
 		chat.appendChild(chat_input);
 		
+		let members_id = client.channels.channel.members_id;
+
 		chat_input.onkeydown = async () => {
 			if (event.keyCode == 13 && client.channels.channel != undefined) {
 				//let chat_input = document.getElementById("input_chat");
 				let chat_text = chat_input.value;
 
 					let receivers_id = [];
-					client.channels.channel.members_id.forEach((member_id) => {
+					members_id.forEach((member_id) => {
 						if (member_id != client.me.id)
 							receivers_id.push(profiles.filter(user => user.id == member_id)[0].id);
 					});
@@ -196,7 +200,7 @@ export default class extends AbstractView {
 		// Scroll to the bottom of messages
 		messages.scrollTop = messages.scrollHeight;
 
-		this.display_invite(chat);
+		this.display_invite();
 
 	}
 
@@ -242,10 +246,13 @@ export default class extends AbstractView {
 	}
 
 	async display_members(chat, profiles) {
+
+		let members_id = client.channels.channel.members_id;
+
 		let members = document.createElement("h2");
 		members.id = "members";
 		let usernames = "";
-		client.channels.channel.members_id.forEach((member_id) => {
+		members_id.forEach((member_id) => {
 			if (member_id != client.me.id) {
 				if (usernames.length > 0)
 					usernames += ", ";
@@ -258,17 +265,66 @@ export default class extends AbstractView {
 		return members
 	}
 
-	async display_invite(chat, profiles) {
+	async display_invite() {
+
+		let chat = document.getElementById("chat");
+
+		if (chat == undefined)
+			return ;
+
+		let members_id = client.channels.channel.members_id;
+		let others = members_id.filter(id => id !== client.me.id);
 
-		// Button to send invite to play
 		let invite = document.getElementById("invite") || document.createElement("button");
-		invite.id = "invite";
+		let yes = document.getElementById("yes") || document.createElement("button");
-		invite.innerText = "invite";
+		let no = document.getElementById("no") || document.createElement("button");
-		invite.onclick = async () => {
+
-			await client.notice.sendInvite(client.me.id, 
+		let invitedBy = undefined;
-				client.channels.channel.members_id.filter(id => id !== client.me.id));
+		for (let x in others) {
-		};
+			if (client.notice.data["invited"].includes(others[x])) {
-		chat.appendChild(invite);
+				invitedBy = others[x];
+			}
+		}
+
+		if (invitedBy == undefined) {
+
+			if (yes && no) {
+				yes.remove();
+				no.remove();
+			}
+
+			// Button to send invite to play
+			invite.id = "invite";
+			invite.style.background = "orange";
+			invite.innerText = "invite";
+			invite.title = "Invite to play a game"
+			invite.onclick = async () => {
+				await client.notice.sendInvite(others);
+			};
+			chat.appendChild(invite);
+		}
+		else {
+
+			if (invite)
+				invite.remove()
+
+			yes.id = "yes";
+			yes.style.background = "green";
+			yes.title = "Accept to play a game"
+			yes.onclick = async () => {
+				await client.notice.acceptInvite(invitedBy);
+			};
+
+			no.id = "no";
+			no.style.background = "red";
+			no.title = "Refuse to play a game"
+			no.onclick = async () => {
+				await client.notice.refuseInvite(invitedBy);
+			};
+
+			chat.appendChild(yes);
+			chat.appendChild(no);
+		}
 
 	}
 

profiles/views.py

@@ -33,7 +33,10 @@ class BlocksView(APIView):
 		users_id = request.data.get("users_id", None)
 
 		if (users_id == None):
-			return Response({"Error"}, status=status.HTTP_400_BAD_REQUEST)
+			return Response({"Error send None"}, status=status.HTTP_400_BAD_REQUEST)
+
+		if (users_id[0] == None or users_id[1] == None):
+			return Response({"Error send blocker/ed None"}, status=status.HTTP_400_BAD_REQUEST)
 
 		if (BlockModel.objects.filter(blocker=users_id[0], blocked=users_id[1])):
 			return Response({"Already Exist"}, status=status.HTTP_409_CONFLICT)
@@ -52,6 +55,9 @@ class BlocksView(APIView):
 		if (users_id == None):
 			return Response({"Error"}, status=status.HTTP_400_BAD_REQUEST)
 
+		if (users_id[0] == None or users_id[1] == None):
+			return Response({"Error send blocker/ed None"}, status=status.HTTP_400_BAD_REQUEST)
+
 		block = BlockModel.objects.filter(blocker=users_id[0], blocked=users_id[1])
 
 		print(list(block))