fixed broadcast roles and permissions

stratoflights_api/consumers.py

@@ -9,31 +9,13 @@ class TelemetryConsumer(AsyncWebsocketConsumer):
     write_enabled = False
 
     async def connect(self):
-        User = get_user_model()
-        from rest_framework.authtoken.models import Token
-        from .models import Satellite
-
-        token_key = self.scope["query_string"].decode().split("token=")[-1]
         self.satellite_id = self.scope["url_route"]["kwargs"]["pk"]
         self.group_name = f"telemetry_{self.satellite_id}"
 
-        user = await self.get_user_from_token(token_key, Token)
-        if not user:
-            await self.send(text_data=json.dumps({"error": "Invalid token"}))
-            await self.close()
-            return
-        self.scope["user"] = user
-
-        try:
-            self.satellite = await database_sync_to_async(Satellite.objects.get)(id=self.satellite_id)
-        except Satellite.DoesNotExist:
-            await self.send(text_data=json.dumps({"error": "Invalid satellite"}))
-            await self.close()
-            return
-
+        # Присоединяемся к группе
         await self.channel_layer.group_add(self.group_name, self.channel_name)
         await self.accept()
-
+        
     async def receive(self, text_data):
         
         from .serializers import TelemetryPacketSerializer
@@ -69,9 +51,9 @@ class TelemetryConsumer(AsyncWebsocketConsumer):
 
     async def telemetry_message(self, event):
         await self.send(text_data=json.dumps(event["data"]))
-
     @database_sync_to_async
     def get_user_from_token(self, token_key, Token):
+        from rest_framework.authtoken.models import Token
         User = get_user_model()
         try:
             token = Token.objects.select_related("user").get(key=token_key)
@@ -81,10 +63,12 @@ class TelemetryConsumer(AsyncWebsocketConsumer):
 
     @database_sync_to_async
     def save_telemetry(self, data):
+        from .models import Satellite
         User = get_user_model()
         from .models import TelemetryPacket
+        satellite = Satellite.objects.get(id=self.satellite_id)
         packet = TelemetryPacket.objects.create(
-            satellite=self.satellite,
+            satellite=satellite,
             user=self.scope["user"],
             timestamp=data.get("timestamp", int(time.time())),
             lat=data.get("lat", 0.0),
@@ -97,10 +81,31 @@ class TelemetryConsumer(AsyncWebsocketConsumer):
 
     
 class SatelliteTelemetryConsumer(TelemetryConsumer):
-    group_prefix = "satellite"
-    write_enabled = True
+    write_enabled = False
+    
+    @classmethod
+    async def broadcast_to_satellite_group(cls, satellite_id, data, channel_layer):
+        group_name = f"telemetry_{satellite_id}"
+        await channel_layer.group_send(
+            group_name,
+            {
+                "type": "telemetry_message",
+                "data": data
+            }
+        )
 
 
 class StationTelemetryConsumer(TelemetryConsumer):
-    group_prefix = "station"
-    write_enabled = False
+    write_enabled = True
+    
+    async def connect(self):
+        from rest_framework.authtoken.models import Token
+        token_key = self.scope["query_string"].decode().split("token=")[-1]
+        try:
+            token = await database_sync_to_async(Token.objects.select_related("user").get)(key=token_key)
+            self.scope["user"] = token.user
+        except Token.DoesNotExist:
+            await self.close()
+            return
+
+        await super().connect()