File size: 10,218 Bytes
1b4f3f8
8dbff89
1b4f3f8
 
38415cf
bf5274e
8dbff89
916c313
8dbff89
 
38415cf
8dbff89
38415cf
bf5274e
38415cf
8dbff89
 
 
 
38415cf
8dbff89
 
38415cf
8dbff89
 
 
 
 
 
38415cf
8dbff89
 
 
 
 
 
 
 
 
 
38415cf
 
8dbff89
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
38415cf
8dbff89
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
bf5274e
8dbff89
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
bf5274e
8dbff89
 
 
 
 
 
 
 
 
 
 
38415cf
8dbff89
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ec380a0
8dbff89
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ec380a0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8dbff89
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
"""
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 utils import log
from config_provider import ConfigProvider, APIConfig
from session import Session

cfg = ConfigProvider.get()

_placeholder = re.compile(r"\{\{\s*([^\}]+?)\s*\}\}")

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)
    
    if isinstance(obj, str):
        return _placeholder.sub(replacer, obj)
    if isinstance(obj, dict):
        return {k: _render(v, session, api_name) for k, v in obj.items()}
    if isinstance(obj, list):
        return [_render(v, session, api_name) for v in obj]
    return obj

def _fetch_token(api: APIConfig, session: Session) -> None:
    """Fetch new auth token"""
    if not api.auth or not api.auth.enabled:
        return
        
    log(f"🔑 Fetching token for {api.name}")
    
    try:
        body = _render(api.auth.token_request_body, session, api.name)
        headers = {"Content-Type": "application/json"}
        
        response = requests.post(
            str(api.auth.token_endpoint),
            json=body,
            headers=headers,
            timeout=api.timeout_seconds
        )
        response.raise_for_status()
        
        json_data = response.json()
        
        # Extract token using path
        token = json_data
        for path_part in api.auth.response_token_path.split("."):
            token = token.get(path_part)
            if token is None:
                raise ValueError(f"Token path {api.auth.response_token_path} not found in response")
        
        # Store in session
        session.auth_tokens[api.name] = {
            "token": token,
            "expiry": time.time() + 3500,  # ~1 hour
            "refresh_token": json_data.get("refresh_token")
        }
        
        log(f"✅ Token obtained for {api.name}")
        
    except Exception as e:
        log(f"❌ Token fetch failed for {api.name}: {e}")
        raise

def _refresh_token(api: APIConfig, session: Session) -> bool:
    """Refresh existing token"""
    if not api.auth or not api.auth.token_refresh_endpoint:
        return False
        
    token_info = session.auth_tokens.get(api.name, {})
    if not token_info.get("refresh_token"):
        return False
    
    log(f"🔄 Refreshing token for {api.name}")
    
    try:
        body = _render(api.auth.token_refresh_body or {}, session, api.name)
        body["refresh_token"] = token_info["refresh_token"]
        
        response = requests.post(
            str(api.auth.token_refresh_endpoint),
            json=body,
            timeout=api.timeout_seconds
        )
        response.raise_for_status()
        
        json_data = response.json()
        
        # Extract new token
        token = json_data
        for path_part in api.auth.response_token_path.split("."):
            token = token.get(path_part)
            if token is None:
                raise ValueError(f"Token path {api.auth.response_token_path} not found in refresh response")
        
        # Update session
        session.auth_tokens[api.name] = {
            "token": token,
            "expiry": time.time() + 3500,
            "refresh_token": json_data.get("refresh_token", token_info["refresh_token"])
        }
        
        log(f"✅ Token refreshed for {api.name}")
        return True
        
    except Exception as e:
        log(f"❌ Token refresh failed for {api.name}: {e}")
        return False

def _ensure_token(api: APIConfig, session: Session) -> None:
    """Ensure valid token exists for API"""
    if not api.auth or not api.auth.enabled:
        return
    
    token_info = session.auth_tokens.get(api.name)
    
    # No token yet
    if not token_info:
        _fetch_token(api, session)
        return
    
    # Token still valid
    if token_info.get("expiry", 0) > time.time():
        return
    
    # Try refresh first
    if _refresh_token(api, session):
        return
    
    # Refresh failed, get new token
    _fetch_token(api, session)

def call_api(api: APIConfig, session: Session) -> requests.Response:
    """Execute API call with automatic token management"""
    # Ensure valid token
    _ensure_token(api, session)
    
    # Prepare request
    headers = _render(api.headers, session, api.name)
    body = _render(api.body_template, session, api.name)
    
    # Handle proxy
    proxies = None
    if api.proxy:
        if isinstance(api.proxy, str):
            proxies = {"http": api.proxy, "https": api.proxy}
        elif hasattr(api.proxy, "enabled") and api.proxy.enabled:
            proxy_url = str(api.proxy.url)
            proxies = {"http": proxy_url, "https": proxy_url}
    
    # Prepare request parameters
    request_params = {
        "method": api.method,
        "url": str(api.url),
        "headers": headers,
        "timeout": api.timeout_seconds
    }
    
    # Add body based on method
    if api.method in ("POST", "PUT", "PATCH"):
        request_params["json"] = body
    elif api.method == "GET" and body:
        request_params["params"] = body
    
    if proxies:
        request_params["proxies"] = proxies
    
    # Execute with retry
    retry_count = api.retry.retry_count if api.retry else 0
    last_error = None
    response = None
    
    for attempt in range(retry_count + 1):
        try:
            log(f"🌐 API call: {api.name} {api.method} {api.url} (attempt {attempt + 1}/{retry_count + 1})")
            
            response = requests.request(**request_params)
            
            # Handle 401 Unauthorized
            if response.status_code == 401 and api.auth and api.auth.enabled and attempt < retry_count:
                log(f"🔒 Got 401, refreshing token for {api.name}")
                _fetch_token(api, session)  # Force new token
                headers = _render(api.headers, session, api.name)  # Re-render headers
                request_params["headers"] = headers
                continue
            
            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
            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()
                        
                        for mapping in api.response_mappings:
                            var_name = mapping.get('variable_name')
                            var_type = mapping.get('type', 'str')
                            json_path = mapping.get('json_path')
                            
                            if not all([var_name, json_path]):
                                continue
                            
                            # JSON path'ten değeri al
                            value = response_json
                            for path_part in json_path.split('.'):
                                if isinstance(value, dict):
                                    value = value.get(path_part)
                                    if value is None:
                                        break
                            
                            if value is not None:
                                # Type conversion
                                if var_type == 'int':
                                    value = int(value)
                                elif var_type == 'float':
                                    value = float(value)
                                elif var_type == 'bool':
                                    value = bool(value)
                                elif var_type == 'date':
                                    # ISO format'ta sakla
                                    value = str(value)
                                else:  # str
                                    value = str(value)
                                
                                # Session'a kaydet
                                session.variables[var_name] = value
                                log(f"📝 Mapped response value: {var_name} = {value}")
                                
                except Exception as e:
                    log(f"⚠️ Response mapping error: {e}")
            
            return response
            
        except requests.exceptions.Timeout as e:
            last_error = e
            log(f"⏱️ API timeout for {api.name} (attempt {attempt + 1})")
            
        except requests.exceptions.RequestException as e:
            last_error = e
            log(f"❌ API error for {api.name}: {e}")
            
        # Retry backoff
        if attempt < retry_count:
            backoff = api.retry.backoff_seconds if api.retry else 2
            if api.retry and api.retry.strategy == "exponential":
                backoff = backoff * (2 ** attempt)
            log(f"⏳ Waiting {backoff}s before retry...")
            time.sleep(backoff)
    
    # All retries failed
    if last_error:
        raise last_error
    raise requests.exceptions.RequestException(f"API call failed after {retry_count + 1} attempts")