frontend: arcade management rework

core/data/schema/arcade.py

@@ -115,6 +115,15 @@ class ArcadeData(BaseData):
             return None
         return result.lastrowid
 
+    async def set_machine_arcade(self, machine_id: int, new_arcade: int) -> bool:
+        sql = machine.update(machine.c.id == machine_id).values(arcade = new_arcade)
+        
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update machine {machine_id} arcade to {new_arcade}")
+            return False
+        return True
+
     async def set_machine_serial(self, machine_id: int, serial: str) -> None:
         result = await self.execute(
             machine.update(machine.c.id == machine_id).values(keychip=serial)
@@ -134,6 +143,60 @@ class ArcadeData(BaseData):
                 f"Failed to update board id for machine {machine_id} -> {boardid}"
             )
 
+    async def set_machine_game(self, machine_id: int, new_game: Optional[str]) -> bool:
+        sql = machine.update(machine.c.id == machine_id).values(game = new_game)
+        
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update machine {machine_id} game to {new_game}")
+            return False
+        return True
+
+    async def set_machine_country(self, machine_id: int, new_country: Optional[str]) -> bool:
+        sql = machine.update(machine.c.id == machine_id).values(country = new_country)
+        
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update machine {machine_id} country to {new_country}")
+            return False
+        return True
+
+    async def set_machine_timezone(self, machine_id: int, new_timezone: Optional[str]) -> bool:
+        sql = machine.update(machine.c.id == machine_id).values(timezone = new_timezone)
+        
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update machine {machine_id} timezone to {new_timezone}")
+            return False
+        return True
+
+    async def set_machine_real_cabinet(self, machine_id: int, is_real: bool = False) -> bool:
+        sql = machine.update(machine.c.id == machine_id).values(is_cab = is_real)
+        
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update machine {machine_id} is_cab to {is_real}")
+            return False
+        return True
+
+    async def set_machine_can_ota(self, machine_id: int, can_ota: bool = False) -> bool:
+        sql = machine.update(machine.c.id == machine_id).values(ota_enable = can_ota)
+        
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update machine {machine_id} ota_enable to {can_ota}")
+            return False
+        return True
+
+    async def set_machine_memo(self, machine_id: int, new_memo: Optional[str]) -> bool:
+        sql = machine.update(machine.c.id == machine_id).values(memo = new_memo)
+        
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update machine {machine_id} memo")
+            return False
+        return True
+
     async def get_arcade(self, id: int) -> Optional[Row]:
         sql = arcade.select(arcade.c.id == id)
         result = await self.execute(sql)
@@ -187,8 +250,11 @@ class ArcadeData(BaseData):
         sql = select(arcade_owner.c.permissions).where(and_(arcade_owner.c.user == user_id, arcade_owner.c.arcade == arcade_id))
         result = await self.execute(sql)
         if result is None:
-            return False
-        return result.fetchone()
+            return None
+        row =  result.fetchone()
+        if row:
+            return row['permissions']
+        return None
 
     async def get_arcade_owners(self, arcade_id: int) -> Optional[Row]:
         sql = select(arcade_owner).where(arcade_owner.c.arcade == arcade_id)
@@ -198,7 +264,7 @@ class ArcadeData(BaseData):
             return None
         return result.fetchall()
 
-    async def add_arcade_owner(self, arcade_id: int, user_id: int) -> None:
+    async def add_arcade_owner(self, arcade_id: int, user_id: int, permissions: int = 1) -> Optional[int]:
         sql = insert(arcade_owner).values(arcade=arcade_id, user=user_id)
 
         result = await self.execute(sql)
@@ -206,6 +272,17 @@ class ArcadeData(BaseData):
             return None
         return result.lastrowid
 
+    async def set_arcade_owner_permissions(self, arcade_id: int, user_id: int, new_permissions: int = 1) -> bool:
+        sql = arcade_owner.update(
+            and_(arcade_owner.c.arcade == arcade_id, arcade_owner.c.user == user_id)
+        ).values(permissions = new_permissions)
+
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update arcade owner permissions to {new_permissions} for user {user_id} arcade {arcade_id}")
+            return False
+        return True
+
     async def get_arcade_by_name(self, name: str) -> Optional[List[Row]]:
         sql = arcade.select(or_(arcade.c.name.like(f"%{name}%"), arcade.c.nickname.like(f"%{name}%")))
         result = await self.execute(sql)
@@ -219,7 +296,49 @@ class ArcadeData(BaseData):
         if result is None:
             return None
         return result.fetchall()
-    
+
+    async def set_arcade_name_nickname(self, arcade_id: int, new_name: Optional[str], new_nickname: Optional[str]) -> bool:
+        sql = arcade.update(arcade.c.id == arcade_id).values(name = new_name, nickname = new_nickname)
+        
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update arcade {arcade_id} name to {new_name}/{new_nickname}")
+            return False
+        return True
+
+    async def set_arcade_region_info(self, arcade_id: int, new_country: Optional[str], new_state: Optional[str], new_city: Optional[str], new_region_id: Optional[int], new_country_id: Optional[int]) -> bool:
+        sql = arcade.update(arcade.c.id == arcade_id).values(
+            country = new_country,
+            state = new_state,
+            city = new_city,
+            region_id = new_region_id,
+            country_id = new_country_id
+        )
+        
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update arcade {arcade_id} regional info to {new_country}/{new_state}/{new_city}/{new_region_id}/{new_country_id}")
+            return False
+        return True
+
+    async def set_arcade_timezone(self, arcade_id: int, new_timezone: Optional[str]) -> bool:
+        sql = arcade.update(arcade.c.id == arcade_id).values(timezone = new_timezone)
+        
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update arcade {arcade_id} timezone to {new_timezone}")
+            return False
+        return True
+
+    async def set_arcade_vpn_ip(self, arcade_id: int, new_ip: Optional[str]) -> bool:
+        sql = arcade.update(arcade.c.id == arcade_id).values(ip = new_ip)
+
+        result = await self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to update arcade {arcade_id} VPN address to {new_ip}")
+            return False
+        return True
+
     async def get_num_generated_keychips(self) -> Optional[int]:
         result = await self.execute(select(func.count("serial LIKE 'A69A%'")).select_from(machine))
         if result: