session updates. mostly

backend/playlist/models/session.py

@@ -10,7 +10,7 @@ class Session(models.Model):
 
     @property
     def is_open(self):
-        return datetime.now() < self.opens
+        return (datetime.now() < self.opens) and self.voting_open
 
     opens = models.DateTimeField(null=True, default=None)
     session_id = models.UUIDField(default=uuid.uuid4, editable=False)

backend/playlist/models/vote.py

@@ -5,7 +5,7 @@ from .session import Session
 
 class Vote(models.Model):
     class Meta:
-        unique_together = ["user", "track"]
+        unique_together = ["user", "track", "session"]
     track = models.ForeignKey('Track', on_delete=models.CASCADE)
     user = models.ForeignKey(User, on_delete=models.CASCADE)
     points = models.IntegerField(validators=[MinValueValidator(1), MaxValueValidator(5)])

backend/voting/consumers.py

@@ -5,67 +5,79 @@ from channels.generic.websocket import WebsocketConsumer
 from django.contrib.auth.models import User
 from muzak.auth import get_user_from_token
 from channels.db import database_sync_to_async
+from playlist.models import Session, Track, Vote
 
 
 class SessionConsumer(WebsocketConsumer):
-    def connect(self):
-        self.session_id = self.scope["url_route"]["kwargs"]["session_id"]
-        self.session_name = f"session_{self.session_id}"
-        # print("---")
-        # print(self.scope)
+	def connect(self):
+		self.session_id = self.scope["url_route"]["kwargs"]["session_id"]
+		self.session_name = f"session_{self.session_id}"
 
-        # Join room group
-        async_to_sync(self.channel_layer.group_add)(
-            self.session_name, self.channel_name
-        )
+		async_to_sync(self.channel_layer.group_add)(
+			self.session_name, self.channel_name
+		)
+		self.accept()
 
-        self.accept()
+	def disconnect(self, close_code):
+		# Leave room group
+		async_to_sync(self.channel_layer.group_discard)(
+			self.session_name, self.channel_name
+		)
 
-    def disconnect(self, close_code):
-        # Leave room group
-        async_to_sync(self.channel_layer.group_discard)(
-            self.session_name, self.channel_name
-        )
+	# Receive message from WebSocket
+	def receive(self, text_data):
+		user = self.scope["user"] # Waarschijnlijk altijd AnonymousUser
 
-    # Receive message from WebSocket
-    def receive(self, text_data):
-        user = self.scope["user"]
-        text_data_json = json.loads(text_data)
-        action = text_data_json["action"]
+		text_data_json = json.loads(text_data)
 
-        # Niet lachen, middleware is moeilijk oké?
-        username = text_data_json.get("username")
-        token = text_data_json.get("token")
-        if token:
-            user = get_user_from_token(token, log=True)
-            print(user)
-        elif username:
-            pass
-            #user = User.objects.get(username=username)
+		# Niet lachen, middleware is moeilijk oké?
+		token = text_data_json.get("token")
+		if token:
+			user = get_user_from_token(token, log=True)
+		print(user)
 
 
-        if action == "message":
-            message = text_data_json["message"]
-            # Send message to room group
-            async_to_sync(self.channel_layer.group_send)(
-                self.session_name, {"type": "chat.message", "message": str(user) + ": " + message}
-            )
-        if action == "login":
-            print("LOGIN", str(user))
-            async_to_sync(self.channel_layer.group_send)(
-                self.session_name, {"type": "announce", "user": str(user)}
-            )
-
-    def announce(self, event):
-        user = event["user"]
-        self.send(text_data=json.dumps({"joined": user}))
+		action = text_data_json.get("action", None)
+		#:w
+		# sessionId = text_data_json.get("sessionId", None)
+		#session = Session.objects.get(id=sessionId)
+		if action == "message":
+			message = text_data_json["message"]
+			# Send message to room group
+			async_to_sync(self.channel_layer.group_send)(
+				self.session_name, {"type": "chat.message", "message": str(user) + ": " + message}
+			)
+		if action == "login":
+			print("LOGIN", str(user))
+			async_to_sync(self.channel_layer.group_send)(
+				self.session_name, {"type": "announce", "user": str(user)}
+			)
+		# if action == "vote":
+		# 	points = text_data_json.get("points", None)
+		# 	track = session.current_track;
+		# 	try:
+		# 		vote = Vote.objects.get(user=user, track=track, session=session)
+		# 		vote.points = points
+		# 		vote.save()
+		# 	except Vote.DoesNotExist:
+		# 		vote = Vote.objects.create(user=user, track=track, points=points, session=session)
+		# 		vote.save()
+		if action == "pause":
+			pass
+		if action == "next":
+			pass
 
 
-    # Receive message from room group
-    def chat_message(self, event):
-        message = event["message"]
+	def announce(self, event):
+		user = event["user"]
+		self.send(text_data=json.dumps({"joined": user}))
 
-        print(self.scope["user"])
 
-        # Send message to WebSocket
-        self.send(text_data=json.dumps({"message": message}))
+	# Receive message from room group
+	def chat_message(self, event):
+		message = event["message"]
+
+		print(self.scope["user"])
+
+		# Send message to WebSocket
+		self.send(text_data=json.dumps({"message": message}))