Update app.py

app.py

@@ -39,9 +39,9 @@ async def generate_file_structure(path='.', encoding='utf-8'):
   
   return file_structure
 
-async def rename_item(websocket, project_name, path,new_name, connected):
+async def rename_item(websocket, key,project_name, path,new_name, connected):
     
-    old_path = os.path.join(os.getcwd(), 'projects', project_name, path)
+    old_path = os.path.join(os.getcwd(),'projects', key,project_name, path)
     new_name = new_name
 
     try:
@@ -67,10 +67,10 @@ async def rename_item(websocket, project_name, path,new_name, connected):
     except Exception as e:
         websockets.broadcast(connected,str(e))
 
-async def delete_item(websocket, project_name, path, connected):
+async def delete_item(websocket, key,project_name, path, connected):
           try:
               
-              item_path = os.path.join(os.getcwd(), 'projects', project_name, path)
+              item_path = os.path.join(os.getcwd(), 'projects', key,project_name, path)
 
               if os.path.exists(item_path):
                   if os.path.isdir(item_path):
@@ -94,8 +94,8 @@ async def delete_item(websocket, project_name, path, connected):
               # print(e)
               websockets.broadcast(connected,str(e))
 
-async def create_file(websocket, project_name, path,name, connected):
-    file_path = os.path.join(os.getcwd(), 'projects', project_name, path,name)
+async def create_file(websocket, key,project_name, path,name, connected):
+    file_path = os.path.join(os.getcwd(), 'projects', ,keyproject_name, path,name)
     # Create the file
     with open(file_path, 'w'):
             pass
@@ -106,8 +106,8 @@ async def create_file(websocket, project_name, path,name, connected):
     websockets.broadcast(connected,json.dumps(event))
     
 
-async def create_folder(websocket, project_name, path,name, connected):
-    folder_path = os.path.join(os.getcwd(), 'projects', project_name, path,name)
+async def create_folder(websocket, key,project_name, path,name, connected):
+    folder_path = os.path.join(os.getcwd(), 'projects', key,project_name, path,name)
     # Create the folder
     os.makedirs(folder_path)
     event = {
@@ -117,9 +117,9 @@ async def create_folder(websocket, project_name, path,name, connected):
     websockets.broadcast(connected,json.dumps(event))
     
 
-async def wirte_file(websocket, project_name, path, content, connected):
+async def wirte_file(websocket, key,project_name, path, content, connected):
     try:
-        file_path = os.path.join(os.getcwd(), 'projects', project_name, path)
+        file_path = os.path.join(os.getcwd(), 'projects', key,project_name, path)
         file_content = content
         with open(file_path, 'w', encoding='utf-8') as file:
             file.write(file_content)
@@ -138,13 +138,14 @@ async def wirte_file(websocket, project_name, path, content, connected):
         
     
 
-async def execute_command(websocket, project_name, command, connected):
-    base_path = os.path.join(os.getcwd(), 'projects', project_name)
+async def execute_command(websocket, key,project_name, command, connected):
+    base_path = os.path.join(os.getcwd(), 'projects', key,project_name)
+    mod_command = f'cd {base_path} && {command}'
 
     try:
         process = await asyncio.create_subprocess_shell(
-            command,
-            cwd=base_path,
+            mod_command,
+            # cwd=base_path,
             stdin=asyncio.subprocess.PIPE,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
@@ -270,7 +271,7 @@ async def play(websocket, game, player, connected):
             }
             websockets.broadcast(connected, json.dumps(event))
 
-async def exe(websocket,connected):
+async def exe(websocket,connected,key):
     """
     Receive and process moves from a player.
 
@@ -285,23 +286,23 @@ async def exe(websocket,connected):
 
         try:
             if event["command"]["type"]=="shell":
-               await execute_command(websocket, event["project_name"], event["command"]["command"], connected)
+               await execute_command(websocket, key,event["project_name"], event["command"]["command"], connected)
             elif event["command"]["type"]=="write":
                 
-                await wirte_file(websocket, event["project_name"], event["path"], event["content"], connected)
+                await wirte_file(websocket, key,event["project_name"], event["path"], event["content"], connected)
             elif event["command"]["type"]=="create":
                 if event["item"]=="folder":
-                    await create_folder(websocket, event["project_name"], event["path"],event["name"], connected)
+                    await create_folder(websocket, key,event["project_name"], event["path"],event["name"], connected)
                 else:
-                    await create_file(websocket, event["project_name"], event["path"],event["name"], connected)
+                    await create_file(websocket, key,event["project_name"], event["path"],event["name"], connected)
                 
                 
             elif event["command"]["type"]=="delete":
                 
-                await delete_item(websocket, event["project_name"], event["path"], connected)
+                await delete_item(websocket, key,event["project_name"], event["path"], connected)
             elif event["command"]["type"]=="rename":
                 
-                await rename_item(websocket, event["project_name"], event["path"], event["name"], connected)
+                await rename_item(websocket, key,event["project_name"], event["path"], event["name"], connected)
             elif event["command"]["type"]=="collabration":
                 
                 event = {
@@ -366,18 +367,18 @@ async def start(websocket,events):
         
         js = json.loads(events)
         assert js["type"] == "init"
-        base_path = os.path.join(os.getcwd(), 'projects', js["project_name"])
+        base_path = os.path.join(os.getcwd(), 'projects',join_key, js["project_name"])
         data=json.loads(js["file_structure"])
         # Receive and process moves from the first player.
         # await play(websocket, game, PLAYER1, connected)
         await create_file_structure(websocket,data, base_path=base_path)
-        await exe(websocket,connected)
+        await exe(websocket,connected,join_key)
     finally:
         del JOIN[join_key]
         del WATCH[watch_key]
 
 
-async def join(websocket, join_key):
+async def join(websocket, key):
     """
     Handle a connection from the second player: join an existing game.
 
@@ -386,16 +387,22 @@ async def join(websocket, join_key):
     try:
         game, connected = JOIN[join_key]
     except KeyError:
-        await error(websocket, "Game not found.")
+        await error(websocket, "collabration not found.")
         return
 
     # Register to receive moves from this game.
     connected.add(websocket)
     try:
+        current_directory = f'projects/{key}'
         # Send the first move, in case the first player already played it.
-        await replay(websocket, game)
+        file_structure = await generate_file_structure(current_directory)
         # Receive and process moves from the second player.
-        await play(websocket, game, PLAYER2, connected)
+        event = {
+            "type": "join",
+            "file_structure": json.dumps(file_structure),
+           
+        }
+        await websocket.send(json.dumps(event))
     finally:
         connected.remove(websocket)