Update api_executor.py

api_executor.py

@@ -4,7 +4,7 @@ Flare – API Executor  (v2.0 · session-aware token management)
 
 from __future__ import annotations
 import json, re, time, requests
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 from utils import log
 from config_provider import ConfigProvider, APIConfig
 from session import Session
@@ -13,31 +13,93 @@ cfg = ConfigProvider.get()
 
 _placeholder = re.compile(r"\{\{\s*([^\}]+?)\s*\}\}")
 
+def _get_variable_value(session: Session, var_path: str) -> Any:
+    """Get variable value with proper type from session"""
+    if var_path.startswith("variables."):
+        var_name = var_path.split(".", 1)[1]
+        return session.variables.get(var_name)
+    elif var_path.startswith("auth_tokens."):
+        parts = var_path.split(".")
+        if len(parts) >= 3:
+            token_api = parts[1]
+            token_field = parts[2]
+            token_data = session.auth_tokens.get(token_api, {})
+            return token_data.get(token_field)
+    elif var_path.startswith("config."):
+        attr_name = var_path.split(".", 1)[1]
+        return getattr(cfg.global_config, attr_name, None)
+    return None
+
+def _render_value(value: Any) -> Union[str, int, float, bool, None]:
+    """Convert value to appropriate JSON type"""
+    if value is None:
+        return None
+    elif isinstance(value, bool):
+        return value
+    elif isinstance(value, (int, float)):
+        return value
+    elif isinstance(value, str):
+        # Check if it's a number string
+        if value.isdigit():
+            return int(value)
+        try:
+            return float(value)
+        except ValueError:
+            pass
+        # Check if it's a boolean string
+        if value.lower() in ('true', 'false'):
+            return value.lower() == 'true'
+        # Return as string
+        return value
+    else:
+        return str(value)
+
+def _render_json(obj: Any, session: Session, api_name: str) -> Any:
+    """Render JSON preserving types"""
+    if isinstance(obj, str):
+        # Check if entire string is a template
+        template_match = _placeholder.fullmatch(obj.strip())
+        if template_match:
+            # This is a pure template like {{variables.pnr}}
+            var_path = template_match.group(1).strip()
+            value = _get_variable_value(session, var_path)
+            return _render_value(value)
+        else:
+            # String with embedded templates or regular string
+            def replacer(match):
+                var_path = match.group(1).strip()
+                value = _get_variable_value(session, var_path)
+                return str(value) if value is not None else ""
+            
+            return _placeholder.sub(replacer, obj)
+    
+    elif isinstance(obj, dict):
+        return {k: _render_json(v, session, api_name) for k, v in obj.items()}
+    
+    elif isinstance(obj, list):
+        return [_render_json(v, session, api_name) for v in obj]
+    
+    else:
+        # Return as-is for numbers, booleans, None
+        return obj
+
 def _render(obj: Any, session: Session, api_name: str) -> Any:
     """Render template with session variables and tokens"""
-    def replacer(match):
-        key = match.group(1)
-        if key.startswith("variables."):
-            var_name = key.split(".", 1)[1]
-            return str(session.variables.get(var_name, ""))
-        if key.startswith("auth_tokens."):
-            parts = key.split(".")
-            if len(parts) >= 3:
-                token_api = parts[1]
-                token_field = parts[2]
-                token_data = session.auth_tokens.get(token_api, {})
-                return str(token_data.get(token_field, ""))
-        if key.startswith("config."):
-            attr_name = key.split(".", 1)[1]
-            return str(getattr(cfg.global_config, attr_name, ""))
-        return match.group(0)
-    
+    # For headers and other string-only contexts
     if isinstance(obj, str):
+        def replacer(match):
+            var_path = match.group(1).strip()
+            value = _get_variable_value(session, var_path)
+            return str(value) if value is not None else ""
+        
         return _placeholder.sub(replacer, obj)
-    if isinstance(obj, dict):
+    
+    elif isinstance(obj, dict):
         return {k: _render(v, session, api_name) for k, v in obj.items()}
-    if isinstance(obj, list):
+    
+    elif isinstance(obj, list):
         return [_render(v, session, api_name) for v in obj]
+    
     return obj
 
 def _fetch_token(api: APIConfig, session: Session) -> None:
@@ -48,7 +110,8 @@ def _fetch_token(api: APIConfig, session: Session) -> None:
     log(f"🔑 Fetching token for {api.name}")
     
     try:
-        body = _render(api.auth.token_request_body, session, api.name)
+        # Use _render_json for body to preserve types
+        body = _render_json(api.auth.token_request_body, session, api.name)
         headers = {"Content-Type": "application/json"}
         
         response = requests.post(
@@ -93,7 +156,7 @@ def _refresh_token(api: APIConfig, session: Session) -> bool:
     log(f"🔄 Refreshing token for {api.name}")
     
     try:
-        body = _render(api.auth.token_refresh_body or {}, session, api.name)
+        body = _render_json(api.auth.token_refresh_body or {}, session, api.name)
         body["refresh_token"] = token_info["refresh_token"]
         
         response = requests.post(
@@ -149,69 +212,14 @@ def _ensure_token(api: APIConfig, session: Session) -> None:
     # Refresh failed, get new token
     _fetch_token(api, session)
 
-def _render_json_preserving_types(obj: Any, session: Session, api_name: str) -> Any:
-    """Render JSON object while preserving variable types"""
-    if isinstance(obj, str):
-        # String içinde template var mı kontrol et
-        if '{{' in obj and '}}' in obj:
-            # Tam template mi kontrol et (örn: "{{variables.count}}" değil de {{variables.count}})
-            template_match = _placeholder.match(obj.strip())
-            if template_match and template_match.group(0) == obj.strip():
-                # Bu tam bir template, tipi koru
-                key = template_match.group(1)
-                if key.startswith("variables."):
-                    var_name = key.split(".", 1)[1]
-                    value = session.variables.get(var_name)
-                    
-                    # Değer tipini koru
-                    if value is None:
-                        return None
-                    elif isinstance(value, bool):
-                        return value
-                    elif isinstance(value, (int, float)):
-                        return value
-                    elif isinstance(value, str):
-                        # Date string'leri olduğu gibi bırak
-                        return value
-                    else:
-                        return str(value)
-            else:
-                # String içinde template var, string olarak render et
-                return _render(obj, session, api_name)
-        else:
-            # Template yok, olduğu gibi dön
-            return obj
-    elif isinstance(obj, dict):
-        return {k: _render_json_preserving_types(v, session, api_name) for k, v in obj.items()}
-    elif isinstance(obj, list):
-        return [_render_json_preserving_types(v, session, api_name) for v in obj]
-    else:
-        # Diğer tipler (int, float, bool, None) olduğu gibi
-        return obj
-        
 def call_api(api: APIConfig, session: Session) -> requests.Response:
     """Execute API call with automatic token management"""
     # Ensure valid token
     _ensure_token(api, session)
     
-    # Prepare headers (bunlar her zaman string)
-    headers = _render(api.headers, session, api.name)
-    
-    # Body template'i özel olarak handle et
-    body = api.body_template
-    
-    # Eğer body_template bir dict ise (JSON object)
-    if isinstance(body, dict):
-        # Doğrudan render et
-        body = _render_json_preserving_types(body, session, api.name)
-    elif isinstance(body, str):
-        # String ise, JSON olup olmadığını kontrol et
-        try:
-            parsed_body = json.loads(body)
-            body = _render_json_preserving_types(parsed_body, session, api.name)
-        except:
-            # JSON değilse, normal string render
-            body = _render(body, session, api.name)
+    # Prepare request
+    headers = _render(api.headers, session, api.name)  # Headers are always strings
+    body = _render_json(api.body_template, session, api.name)  # Body preserves types
     
     # Handle proxy
     proxies = None
@@ -247,6 +255,7 @@ def call_api(api: APIConfig, session: Session) -> requests.Response:
     for attempt in range(retry_count + 1):
         try:
             log(f"🌐 API call: {api.name} {api.method} {api.url} (attempt {attempt + 1}/{retry_count + 1})")
+            log(f"📋 Request body: {json.dumps(body, ensure_ascii=False)}")
             
             response = requests.request(**request_params)
             
@@ -261,10 +270,9 @@ def call_api(api: APIConfig, session: Session) -> requests.Response:
             response.raise_for_status()
             log(f"✅ API call successful: {api.name} ({response.status_code})")
             
-            # Response mapping işlemi - başarılı her response için
+            # Response mapping işlemi
             if response.status_code in (200, 201, 202, 204) and hasattr(api, 'response_mappings') and api.response_mappings:
                 try:
-                    # 204 No Content durumunda JSON parse etmeye çalışma
                     if response.status_code != 204 and response.content:
                         response_json = response.json()