Update app.py

app.py

@@ -1,28 +1,27 @@
 import requests
 import json
 from uuid import UUID
-from typing import Dict, Any, Optional
 import gradio as gr
 import os
 import threading
 import time
 import pandas as pd
 
-# Lấy ZGM API Token từ biến môi trường (Secrets trên Hugging Face)
+# Get ZGM API Token from environment variables
 ZGM_API_TOKEN = os.getenv("ZGM_API_TOKEN")
 if not ZGM_API_TOKEN:
-    raise ValueError("ZGM_API_TOKEN không được tìm thấy trong biến môi trường!")
+    raise ValueError("ZGM_API_TOKEN not found in environment variables!")
 
-# Lấy địa chỉ IP của VPS từ Secrets
+# Get VPS IP from environment variables
 VPS_IP = os.getenv("VPS_IP")
 if not VPS_IP:
-    raise ValueError("VPS_IP không được tìm thấy trong biến môi trường!")
+    raise ValueError("VPS_IP not found in environment variables!")
 
-# URL của API trên VPS (dùng port 3000)
+# VPS API URL
 KEY_API_URL = f"http://{VPS_IP}:3000"
 
 class ZGMApiClient:
-    """Lớp client để tương tác với ZGM API"""
+    """Client class to interact with ZGM API"""
     
     def __init__(self, base_url: str, api_token: str):
         self.base_url = base_url.rstrip('/')
@@ -47,82 +46,75 @@ class ZGMApiClient:
             response.raise_for_status()
             return response.json()
         except requests.exceptions.ConnectTimeout:
-            return {"error": f"Không thể kết nối đến {self.base_url}. Vui lòng kiểm tra URL hoặc mạng.", "status_code": 0}
+            return {"error": f"Could not connect to {self.base_url}. Please check URL or network.", "status_code": 0}
         except requests.exceptions.HTTPError as e:
             if response.status_code == 401:
-                return {"error": "Chưa đăng nhập. Vui lòng kiểm tra API Token.", "status_code": 401}
+                return {"error": "Not logged in. Please check API Token.", "status_code": 401}
             elif response.status_code == 500:
-                return {"error": "Lỗi server từ ZGM API.", "status_code": 500}
-            return {"error": f"Lỗi HTTP: {str(e)}", "status_code": response.status_code}
+                return {"error": "Server error from ZGM API.", "status_code": 500}
+            return {"error": f"HTTP Error: {str(e)}", "status_code": response.status_code}
         except requests.exceptions.RequestException as e:
-            return {"error": f"Lỗi kết nối: {str(e)}", "status_code": 0}
+            return {"error": f"Connection Error: {str(e)}", "status_code": 0}
 
-    def rent_otp(self, service: str) -> Dict:
+    def rent_mail(self, service: str) -> Dict:
         data = {"service": service}
-        return self._make_request('POST', '/api/mail/otp-rent', data=data)
+        return self._make_request('POST', '/api/mail/rent', data=data)
 
     def get_otp(self, order_id: str) -> Dict:
         try:
             UUID(order_id)
-            return self._make_request('GET', '/api/mail/otp-get', params={"orderId": order_id})
+            return self._make_request('GET', '/api/mail/otp', params={"orderId": order_id})
         except ValueError:
-            return {"error": "order_id phải là UUID hợp lệ", "status_code": 400}
+            return {"error": "order_id must be a valid UUID", "status_code": 400}
 
-# Khởi tạo client
+# Initialize client
 client = ZGMApiClient("https://gm.haivl.wtf", ZGM_API_TOKEN)
 
-# Hàm kiểm tra key từ API trên VPS mà không xóa
+# Validate key from VPS API
 def validate_key_from_api(access_key: str) -> tuple[bool, str]:
     try:
         response = requests.get(f"{KEY_API_URL}/api/keys/validate", params={"key": access_key}, timeout=5)
-        print(f"Validate API Response: {response.text}")  # Debug log
         response.raise_for_status()
         data = response.json()
         if data["valid"]:
-            return True, f"Còn lại {data['remaining']} key."
+            return True, f"Remaining keys: {data['remaining']}."
         else:
-            return False, "Key không hợp lệ! Vui lòng nhập key hợp lệ để tiếp tục."
+            return False, "Invalid key! Please enter a valid key."
     except requests.exceptions.RequestException as e:
-        print(f"Validate API Error: {str(e)}")  # Debug log
-        return False, f"Lỗi khi kiểm tra key từ API: {str(e)}"
+        return False, f"Error checking key from API: {str(e)}"
 
-# Hàm xóa key từ API trên VPS
+# Remove key from VPS API
 def remove_key_from_api(access_key: str) -> tuple[bool, str]:
     try:
         response = requests.delete(f"{KEY_API_URL}/api/keys/remove", params={"key": access_key}, timeout=5)
-        print(f"Remove API Response: {response.text}")  # Debug log
         response.raise_for_status()
         data = response.json()
         if data["success"]:
-            return True, f"Còn lại {data['remaining']} key."
+            return True, f"Remaining keys: {data['remaining']}."
         else:
-            return False, "Không thể xóa key."
+            return False, "Failed to remove key."
     except requests.exceptions.RequestException as e:
-        print(f"Remove API Error: {str(e)}")  # Debug log
-        return False, f"Lỗi khi xóa key từ API: {str(e)}"
+        return False, f"Error removing key from API: {str(e)}"
 
-# Hàm xác thực và xóa key
+# Validate and remove key
 def validate_and_remove_key(access_key: str, result: Dict) -> tuple[bool, str]:
-    # Kiểm tra key có hợp lệ không
     is_valid, message = validate_key_from_api(access_key)
-    print(f"Input Key: {access_key}, Valid: {is_valid}")  # Debug log
     if not is_valid:
         return False, message
     
-    # Chỉ xóa key khi thuê OTP thành công
     if result.get("code") == 200 and result.get("data") and "orderId" in result["data"] and "email" in result["data"]:
         success, remove_message = remove_key_from_api(access_key)
         if not success:
-            return True, f"Thuê OTP thành công nhưng {remove_message}"
-        remaining_keys = int(remove_message.split("Còn lại ")[1].split(" key")[0])
-        remaining_message = f"Còn lại {remaining_keys} key."
+            return True, f"Mail rented successfully but {remove_message}"
+        remaining_keys = int(remove_message.split("Remaining keys: ")[1].split(".")[0])
+        remaining_message = f"Remaining keys: {remaining_keys}."
         if remaining_keys < 100:
-            remaining_message += " Số lượng key còn ít! Vui lòng tạo thêm key mới."
+            remaining_message += " Low key count! Please add more keys."
         return True, remaining_message
     else:
-        return True, f"Lỗi: {result.get('message', 'Không thể thuê Gmail.')}\nKey không bị xóa."
+        return True, f"Error: {result.get('message', 'Failed to rent mail.')}\nKey not removed."
 
-# Hàm xử lý bất đồng bộ với chỉ báo tải
+# Async execution with loading indicator
 def execute_with_loading(func, *args, **kwargs):
     result = [None]
     is_loading = [True]
@@ -137,7 +129,7 @@ def execute_with_loading(func, *args, **kwargs):
     chars = "|/-\\"
     i = 0
     while is_loading[0]:
-        print(f"\rĐang tải {chars[i % len(chars)]}", end="")
+        print(f"\rLoading {chars[i % len(chars)]}", end="")
         i += 1
         time.sleep(0.1)
     print("\r", end="")
@@ -145,10 +137,10 @@ def execute_with_loading(func, *args, **kwargs):
     api_thread.join()
     return result[0]
 
-# Hàm định dạng kết quả "Thuê OTP" thành bảng (chỉ Order ID và Email)
-def format_rent_otp_result(data: Dict) -> pd.DataFrame:
+# Format rent mail result
+def format_rent_result(data: Dict) -> pd.DataFrame:
     if not data or "data" not in data:
-        return pd.DataFrame([["Không có dữ liệu để hiển thị."]], columns=["Message"])
+        return pd.DataFrame([["No data to display."]], columns=["Message"])
     order_info = data["data"]
     df = pd.DataFrame([{
         "Order ID": order_info.get("orderId", "N/A"),
@@ -156,136 +148,120 @@ def format_rent_otp_result(data: Dict) -> pd.DataFrame:
     }])
     return df
 
-# Hàm định dạng kết quả "Lấy OTP" thành bảng (Service, Email, OTP Code, và nội dung thư)
-def format_get_otp_result(data: Dict, selected_service: str) -> pd.DataFrame:
+# Format OTP result
+def format_otp_result(data: Dict, selected_service: str) -> pd.DataFrame:
     if not data or "data" not in data:
-        return pd.DataFrame([["Không có dữ liệu để hiển thị."]], columns=["Message"])
+        return pd.DataFrame([["No data to display."]], columns=["Message"])
     
     otp_data = data["data"]
     
-    # Nếu là đối tượng đơn (không phải danh sách)
     if isinstance(otp_data, dict):
-        otp_data = [otp_data]  # Chuyển thành danh sách để xử lý thống nhất
+        otp_data = [otp_data]
     
-    # Nếu không phải danh sách, dữ liệu không hợp lệ
     if not isinstance(otp_data, list):
-        return pd.DataFrame([["Dữ liệu không hợp lệ."]], columns=["Message"])
+        return pd.DataFrame([["Invalid data format."]], columns=["Message"])
     
     df = pd.DataFrame([
         {
-            "Service": selected_service,  # Sử dụng dịch vụ đã chọn khi thuê
-            "Email": item.get("email", "N/A"),  # Thêm email vào log
+            "Service": selected_service,
+            "Email": item.get("email", "N/A"),
             "OTP Code": item.get("otpCode", "N/A"),
-            "Content": item.get("otpContent", "N/A")  # Nội dung thư từ API
+            "Content": item.get("otpContent", "N/A")
         }
         for item in otp_data
     ])
     return df
 
-# Hàm xóa tất cả log
+# Clear all logs
 def clear_all_logs():
-    return pd.DataFrame([["Chưa có dữ liệu"]], columns=["Message"]), pd.DataFrame([["Chưa có dữ liệu"]], columns=["Message"]), ""
+    return pd.DataFrame([["No data yet"]], columns=["Message"]), pd.DataFrame([["No data yet"]], columns=["Message"]), ""
 
-# Hàm giao diện Gradio
-def gradio_interface(access_key, action, service, order_id, rent_otp_log, get_otp_log):
-    message = ""
-    new_order_id = order_id  # Giữ nguyên order_id nếu không có thay đổi
-    
-    # Khởi tạo log nếu chưa có
-    if rent_otp_log is None:
-        rent_otp_log = pd.DataFrame([["Chưa có dữ liệu"]], columns=["Message"])
-    if get_otp_log is None:
-        get_otp_log = pd.DataFrame([["Chưa có dữ liệu"]], columns=["Message"])
-
-    # Chỉ yêu cầu key cho hành động "Thuê OTP"
-    if action == "Thuê OTP":
-        if not access_key:
-            rent_otp_log = pd.DataFrame([["Vui lòng nhập key để thực hiện Thuê OTP!"]], columns=["Message"])
-            return rent_otp_log, get_otp_log, message, order_id
-        if not service:
-            rent_otp_log = pd.DataFrame([["Vui lòng chọn dịch vụ!"]], columns=["Message"])
-            return rent_otp_log, get_otp_log, message, order_id
-        result = execute_with_loading(client.rent_otp, service)
-        is_valid, message = validate_and_remove_key(access_key, result)
-        if not is_valid:
-            rent_otp_log = pd.DataFrame([[message]], columns=["Message"])
-            return rent_otp_log, get_otp_log, message, order_id
-        if result.get("code") == 200:
-            rent_otp_log = format_rent_otp_result(result)
-            # Lấy Order ID mới để tự động điền
-            new_order_id = result["data"].get("orderId", order_id)
-        else:
-            rent_otp_log = pd.DataFrame([[json.dumps(result, indent=2, ensure_ascii=False)]], columns=["Message"])
-        return rent_otp_log, get_otp_log, message, new_order_id
-    elif action == "Lấy OTP":
-        if not order_id:
-            get_otp_log = pd.DataFrame([["Vui lòng nhập Order ID!"]], columns=["Message"])
-            return rent_otp_log, get_otp_log, "", order_id
-        result = execute_with_loading(client.get_otp, order_id)
-        if result.get("code") == 200 and "data" in result:
-            get_otp_log = format_get_otp_result(result, service)  # Truyền service đã chọn
-        else:
-            get_otp_log = pd.DataFrame([[json.dumps(result, indent=2, ensure_ascii=False)]], columns=["Message"])
-        return rent_otp_log, get_otp_log, "", order_id
-    else:
-        return rent_otp_log, get_otp_log, "Hành động không hợp lệ!", order_id
-
-# Danh sách dịch vụ cố định
+# Services list
 SERVICES = [
     "ICLOUD", "ZSK", "FACEBOOK", "TELEGRAM", "OTHERS",
     "GGPLAY", "INSTAGRAM", "FMCPAY", "AMAZON"
 ]
 
-# Tạo giao diện Gradio
+# Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("## ZGM API Client - Nhập Key để Thuê OTP (Key chỉ cần thiết cho Thuê OTP, mỗi key dùng 1 lần)")
+    gr.Markdown("## ZGM API Client - Rent Temporary Emails for OTP Services")
     
     with gr.Row():
-        access_key = gr.Textbox(label="Nhập Key Truy Cập (Chỉ cần cho Thuê OTP)", placeholder="Nhập key 32 ký tự...")
-        action = gr.Dropdown(
-            label="Chọn Hành Động",
-            choices=["Thuê OTP", "Lấy OTP"],
-            value="Thuê OTP"
-        )
+        access_key = gr.Textbox(label="Access Key (Required for renting)", placeholder="Enter your 32-character key...")
+        service = gr.Dropdown(label="Service", choices=SERVICES)
     
     with gr.Row():
-        service = gr.Dropdown(label="Dịch Vụ (Cho Thuê OTP)", choices=SERVICES)
-        order_id = gr.Textbox(label="Order ID (Cho Lấy OTP)", placeholder="Nhập Order ID")
+        order_id = gr.Textbox(label="Order ID", placeholder="Enter Order ID from rented mail")
     
-    rent_otp_log = gr.State(value=pd.DataFrame([["Chưa có dữ liệu"]], columns=["Message"]))
-    get_otp_log = gr.State(value=pd.DataFrame([["Chưa có dữ liệu"]], columns=["Message"]))
+    rent_result = gr.State(value=pd.DataFrame([["No data yet"]], columns=["Message"]))
+    otp_result = gr.State(value=pd.DataFrame([["No data yet"]], columns=["Message"]))
     
     with gr.Row():
-        rent_otp_output = gr.Dataframe(
-            label="Log Thuê OTP",
+        rent_output = gr.Dataframe(
+            label="Rented Mail",
             headers=["Order ID", "Email"],
             datatype=["str", "str"],
             interactive=False
         )
-        get_otp_output = gr.Dataframe(
-            label="Log Lấy OTP",
+        otp_output = gr.Dataframe(
+            label="OTP Results",
             headers=["Service", "Email", "OTP Code", "Content"],
             datatype=["str", "str", "str", "str"],
             interactive=False
         )
     
-    message_output = gr.Textbox(label="Thông Báo", interactive=False)
+    message_output = gr.Textbox(label="Status Message", interactive=False)
     
     with gr.Row():
-        submit_btn = gr.Button("Thực Thi", variant="primary")
-        clear_btn = gr.Button("Xóa Log", variant="secondary")
+        rent_btn = gr.Button("Rent Mail", variant="primary")
+        get_otp_btn = gr.Button("Get OTP", variant="primary")
+        clear_btn = gr.Button("Clear Logs", variant="secondary")
+    
+    def rent_mail_action(access_key, service, rent_result, otp_result):
+        if not access_key:
+            return pd.DataFrame([["Please enter access key!"]], columns=["Message"]), otp_result, "Access key required", rent_result
+        if not service:
+            return pd.DataFrame([["Please select service!"]], columns=["Message"]), otp_result, "Service required", rent_result
+        
+        result = execute_with_loading(client.rent_mail, service)
+        is_valid, message = validate_and_remove_key(access_key, result)
+        if not is_valid:
+            return pd.DataFrame([[message]], columns=["Message"]), otp_result, message, rent_result
+        
+        if result.get("code") == 200:
+            df = format_rent_result(result)
+            new_order_id = result["data"].get("orderId", "")
+            return df, otp_result, message, new_order_id
+        else:
+            return pd.DataFrame([[json.dumps(result, indent=2, ensure_ascii=False)]], columns=["Message"]), otp_result, message, rent_result
+    
+    def get_otp_action(order_id, service, rent_result, otp_result):
+        if not order_id:
+            return rent_result, pd.DataFrame([["Please enter Order ID!"]], columns=["Message"]), "", rent_result
+        
+        result = execute_with_loading(client.get_otp, order_id)
+        if result.get("code") == 200 and "data" in result:
+            df = format_otp_result(result, service)
+            return rent_result, df, "", rent_result
+        else:
+            return rent_result, pd.DataFrame([[json.dumps(result, indent=2, ensure_ascii=False)]], columns=["Message"]), "", rent_result
+    
+    rent_btn.click(
+        fn=rent_mail_action,
+        inputs=[access_key, service, rent_result, otp_result],
+        outputs=[rent_output, otp_output, message_output, order_id]
+    )
     
-    submit_btn.click(
-        fn=gradio_interface,
-        inputs=[access_key, action, service, order_id, rent_otp_log, get_otp_log],
-        outputs=[rent_otp_output, get_otp_output, message_output, order_id]
+    get_otp_btn.click(
+        fn=get_otp_action,
+        inputs=[order_id, service, rent_result, otp_result],
+        outputs=[rent_output, otp_output, message_output, order_id]
     )
     
     clear_btn.click(
         fn=clear_all_logs,
         inputs=None,
-        outputs=[rent_otp_output, get_otp_output, message_output]
+        outputs=[rent_output, otp_output, message_output]
     )
 
-# Khởi chạy giao diện
 demo.launch()