5

bot/services/mikopbx_service.py

@@ -27,8 +27,9 @@ class MikoPBXService:
 
     def _get_auth_headers(self) -> Dict[str, str]:
         headers = {
-            "Content-Type": "application/json",
+            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
-            "Accept": "application/json"
+            "Accept": "application/json",
+            "X-Requested-With": "XMLHttpRequest"
         }
         if self.api_token:
             headers["Authorization"] = f"Bearer {self.api_token}"
@@ -41,7 +42,7 @@ class MikoPBXService:
             logger.info(">>> Using Basic Auth (fallback)")
         return headers
 
-    async def _make_request(self, method: str, endpoint: str, json_data: Optional[Dict] = None, params: Optional[Dict] = None):
+    async def _make_request(self, method: str, endpoint: str, data: Optional[Dict] = None, params: Optional[Dict] = None):
         session = await self._get_session()
         url = f"{self.host}{endpoint}"
         headers = self._get_auth_headers()
@@ -50,31 +51,22 @@ class MikoPBXService:
         logger.info(f">>> REQUEST: {method.upper()} {url}")
         if params:
             logger.info(f">>> PARAMS: {params}")
-        if json_data:
+        if data:
-            logger.info(f">>> BODY:\n{json.dumps(json_data, indent=2, ensure_ascii=False)}")
+            logger.info(f">>> BODY: {data}")
-        logger.info(f">>> HEADERS: { {k: v for k, v in headers.items() if k != 'Authorization'} }")
 
         try:
             if method.upper() == "GET":
                 async with session.get(url, params=params, headers=headers) as resp:
                     text = await resp.text()
-                    logger.info(f"<<< RESPONSE [{resp.status}]:\n{text[:3000]}")
+                    logger.info(f"<<< RESPONSE [{resp.status}]:\n{text[:2500]}")
-                    try:
-                        return await resp.json()
-                    except:
-                        return {"result": False, "raw": text}
-            elif method.upper() == "DELETE":
-                async with session.delete(url, headers=headers) as resp:
-                    text = await resp.text()
-                    logger.info(f"<<< RESPONSE [{resp.status}]:\n{text[:3000]}")
                     try:
                         return await resp.json()
                     except:
                         return {"result": False, "raw": text}
             else:
-                async with session.post(url, json=json_data, headers=headers) as resp:
+                async with session.post(url, data=data, headers=headers) as resp:
                     text = await resp.text()
-                    logger.info(f"<<< RESPONSE [{resp.status}]:\n{text[:3000]}")
+                    logger.info(f"<<< RESPONSE [{resp.status}]:\n{text[:2500]}")
                     try:
                         return await resp.json()
                     except:
@@ -83,76 +75,71 @@ class MikoPBXService:
             logger.error(f"!!! REQUEST ERROR: {e}")
             return {"result": False, "messages": [str(e)]}
 
-    # ==================== EXTENSIONS ====================
+    # ==================== EXTENSIONS (legacy but working) ====================
 
     async def get_extension_template(self) -> Optional[Dict]:
-        """Получить шаблон нового сотрудника"""
+        """Получаем шаблон через старый, но рабочий эндпоинт"""
-        logger.info(">>> Trying to get extension template...")
+        logger.info(">>> Getting extension template via legacy endpoint...")
-        
-        # Пробуем v3
         response = await self._make_request(
             "GET", 
-            "/pbxcore/api/v3/extensions", 
+            "/pbxcore/api/extensions/getRecord", 
             params={"id": ""}
         )
-        
+        if response.get("result"):
-        data = response.get("data")
+            logger.info(">>> Template received successfully")
-        
+            return response.get("data")
-        if isinstance(data, dict):
+        logger.error(f">>> Failed to get template: {response.get('messages')}")
-            logger.info(">>> Template received as dict")
-            return data
-        elif isinstance(data, list) and len(data) > 0:
-            logger.info(">>> Template received as list, using first item as template")
-            return data[0].copy() if isinstance(data[0], dict) else None
-        else:
-            logger.warning(">>> Could not get template from API. Will use minimal structure.")
         return None
 
     async def create_extension(self, number: str, secret: str = None, username: str = "", email: str = "") -> Dict[str, Any]:
         logger.info(f"\n>>> Creating extension {number}...")
 
         template = await self.get_extension_template()
-        
         if not template:
-            logger.warning(">>> Using minimal fallback template")
+            return {"success": False, "error": "Failed to get template from MikoPBX"}
-            template = {
-                "type": "SIP",
-                "show_in_phonebook": "1",
-                "is_general_user_number": "1",
-            }
 
-        # Заполняем данными
+        # Заполняем шаблон
         template["number"] = number
         if username:
             template["user_username"] = username
         if email:
             template["user_email"] = email
+        template["type"] = "SIP"
+        template["show_in_phonebook"] = "1"
+        template["is_general_user_number"] = "1"
+
         if secret:
             template["sip_secret"] = secret
 
-        logger.info(f">>> Final creation payload prepared")
+        logger.info(f">>> Sending saveRecord request...")
 
         response = await self._make_request(
             "POST",
-            "/pbxcore/api/v3/extensions",
+            "/pbxcore/api/extensions/saveRecord",
-            json_data=template
+            data=template
         )
         
         if response.get("result"):
+            logger.info(">>> Extension created successfully!")
             return {
                 "success": True,
                 "number": number,
                 "data": response.get("data", {})
             }
         else:
-            error_msg = response.get("messages") or response.get("error") or ["Unknown error"]
+            error = response.get("messages", ["Unknown error"])
+            logger.error(f">>> Creation failed: {error}")
             return {
                 "success": False,
-                "error": error_msg
+                "error": error
             }
 
     async def get_extension(self, number: str) -> Optional[Dict]:
-        response = await self._make_request("GET", f"/pbxcore/api/v3/extensions/{number}")
+        response = await self._make_request(
+            "GET", 
+            "/pbxcore/api/extensions/getRecord", 
+            params={"id": number}
+        )
         return response.get("data") if response.get("result") else None
 
     async def set_extension_secret(self, number: str, new_secret: str) -> Dict[str, Any]:
@@ -160,11 +147,23 @@ class MikoPBXService:
         if not current:
             return {"success": False, "error": "Extension not found"}
         current["sip_secret"] = new_secret
-        response = await self._make_request("PUT", f"/pbxcore/api/v3/extensions/{number}", json_data=current)
+        response = await self._make_request(
+            "POST", 
+            "/pbxcore/api/extensions/saveRecord", 
+            data=current
+        )
         return {"success": response.get("result", False), "messages": response.get("messages", [])}
 
     async def delete_extension(self, number: str) -> Dict[str, Any]:
-        response = await self._make_request("DELETE", f"/pbxcore/api/v3/extensions/{number}")
+        current = await self.get_extension(number)
+        if not current:
+            return {"success": False, "error": "Extension not found"}
+        record_id = current.get("id") or number
+        response = await self._make_request(
+            "POST", 
+            "/pbxcore/api/extensions/deleteRecord", 
+            data={"id": record_id}
+        )
         return {"success": response.get("result", False), "messages": response.get("messages", [])}
 
     async def close(self):