Upload 6 files

api_server.py

@@ -0,0 +1,915 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import json
+import asyncio
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks, Query, Depends, UploadFile, File, Body, Header
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
+from pydantic import BaseModel, Field
+import uvicorn
+
+from unibo_jetbrains_activation import (
+    DatabaseManager, JetbrainsSubmitter, LinkExtractor, ProcessController,
+    STATUS_PENDING, STATUS_SUBMITTED, STATUS_FAILED, STATUS_LINK_EXTRACTED
+)
+from loguru import logger
+
+# 配置日志
+logger.remove()
+logger.add("api_server.log", rotation="1 MB", level="INFO")
+logger.add(lambda msg: print(msg, end=""), level="INFO")
+
+# 创建FastAPI应用
+app = FastAPI(
+    title="JetBrains激活链接管理系统",
+    description="管理JetBrains激活链接的获取流程，包括提交邮箱和提取链接",
+    version="1.0.0"
+)
+
+# 允许跨域请求
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # 在生产环境中应该替换为实际的前端域名
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 创建全局的ProcessController实例
+controller = ProcessController()
+
+# 定义环境变量
+ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "admin123")
+# API_TOKEN = os.environ.get("API_TOKEN", "unibo_token")
+
+def verify_token(token: str = Header(None)):
+    if token != ADMIN_PASSWORD:
+        raise HTTPException(status_code=401, detail="无效的token")
+
+# 定义请求和响应模型
+class AccountItem(BaseModel):
+    id: Optional[int] = None
+    register_time: str
+    username: str
+    password: str
+    security_email: Optional[str] = None
+    status: int = 0
+    activation_link: Optional[str] = None
+    notes: Optional[str] = None
+    updated_at: Optional[str] = None
+    used: Optional[int] = 0
+
+class AccountsResponse(BaseModel):
+    accounts: List[AccountItem]
+    total: int
+
+class SubmitRequest(BaseModel):
+    account_ids: List[int] = []
+    max_workers: int = 3
+    proxy: Optional[str] = None
+
+class ExtractRequest(BaseModel):
+    account_ids: List[int] = []
+    max_workers: int = 1
+
+class ProcessResponse(BaseModel):
+    success_count: int
+    error_count: int
+    details: Optional[Dict[str, Any]] = None
+
+class ImportRequest(BaseModel):
+    filepath: str
+
+class ImportResponse(BaseModel):
+    imported_count: int
+    total_accounts: int
+
+class ExportRequest(BaseModel):
+    status: Optional[int] = None
+    filename: Optional[str] = "export_accounts.txt"
+
+class ExportResponse(BaseModel):
+    exported_count: int
+    filepath: str
+
+class StatusCounts(BaseModel):
+    total: int = 0
+    pending: int = 0
+    submitted: int = 0
+    failed: int = 0
+    link_extracted: int = 0
+    unused: int = 0  # 新增
+
+class StatusUpdateRequest(BaseModel):
+    status: int
+    notes: Optional[str] = None
+    activation_link: Optional[str] = None
+
+class BatchToggleUsedRequest(BaseModel):
+    ids: list[int]
+    used: int
+
+# 后台任务
+running_tasks = {}
+
+async def process_submit_task(task_id: str, account_ids: List[int], max_workers: int, proxy: Optional[str] = None):
+    """后台提交邮箱任务（并发版）"""
+    try:
+        # 获取要处理的账号
+        accounts = []
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            if account_ids:
+                # 处理指定的账号
+                for account_id in account_ids:
+                    cursor.execute(
+                        "SELECT id, register_time, username, password, security_email, status, activation_link FROM accounts WHERE id = ?",
+                        (account_id,)
+                    )
+                    row = cursor.fetchone()
+                    if row:
+                        accounts.append({
+                            'id': row[0],
+                            'register_time': row[1],
+                            'username': row[2],
+                            'password': row[3],
+                            'security_email': row[4],
+                            'status': row[5],
+                            'activation_link': row[6]
+                        })
+            else:
+                # 处理所有未提交的账号
+                cursor.execute(
+                    "SELECT id, register_time, username, password, security_email, status, activation_link FROM accounts WHERE status = ?",
+                    (STATUS_PENDING,)
+                )
+                for row in cursor.fetchall():
+                    accounts.append({
+                        'id': row[0],
+                        'register_time': row[1],
+                        'username': row[2],
+                        'password': row[3],
+                        'security_email': row[4],
+                        'status': row[5],
+                        'activation_link': row[6]
+                    })
+        
+        # 设置代理（如果提供）
+        if proxy:
+            submitter = JetbrainsSubmitter(controller.db_manager, proxy)
+        else:
+            submitter = controller.submitter
+
+        success_count = 0
+        error_count = 0
+        results = []
+
+        sem = asyncio.Semaphore(max_workers)
+
+        async def handle_account(account):
+            nonlocal success_count, error_count
+            try:
+                async with sem:
+                    controller.db_manager.log_operation(
+                        account['username'],
+                        "submit_email_background",
+                        "processing",
+                        f"任务ID: {task_id}"
+                    )
+                    # 提交邮箱（同步方法用run_in_executor）
+                    loop = asyncio.get_running_loop()
+                    result = await loop.run_in_executor(None, submitter.submit_email, account)
+                    if result:
+                        success_count += 1
+                    else:
+                        error_count += 1
+                    await asyncio.sleep(1)
+            except Exception as e:
+                error_count += 1
+                error_msg = str(e)
+                controller.db_manager.update_account_status(
+                    account['id'],
+                    STATUS_FAILED,
+                    notes=f"后台任务异常: {error_msg[:100]}"
+                )
+                controller.db_manager.log_operation(
+                    account['username'],
+                    "submit_email_background",
+                    "error",
+                    error_msg[:200]
+                )
+
+        tasks_list = [handle_account(account) for account in accounts]
+        await asyncio.gather(*tasks_list)
+
+        running_tasks[task_id] = {
+            "status": "completed",
+            "success_count": success_count,
+            "error_count": error_count,
+            "total": len(accounts)
+        }
+    except Exception as e:
+        logger.error(f"后台提交任务 {task_id} 执行失败: {str(e)}")
+        running_tasks[task_id] = {
+            "status": "failed",
+            "error": str(e)
+        }
+
+async def process_extract_task(task_id: str, account_ids: List[int], max_workers: int):
+    """后台提取链接任务（并发版）"""
+    try:
+        # 获取要处理的账号
+        accounts = []
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            if account_ids:
+                # 处理指定的账号
+                for account_id in account_ids:
+                    cursor.execute(
+                        "SELECT id, register_time, username, password, security_email, status, activation_link FROM accounts WHERE id = ?",
+                        (account_id,)
+                    )
+                    row = cursor.fetchone()
+                    if row and row[5] == STATUS_SUBMITTED:  # 仅处理已提交的账号
+                        accounts.append({
+                            'id': row[0],
+                            'register_time': row[1],
+                            'username': row[2],
+                            'password': row[3],
+                            'security_email': row[4],
+                            'status': row[5],
+                            'activation_link': row[6]
+                        })
+            else:
+                # 处理所有已提交但未提取链接的账号
+                cursor.execute(
+                    "SELECT id, register_time, username, password, security_email, status, activation_link FROM accounts WHERE status = ? AND (activation_link IS NULL OR activation_link = '')",
+                    (STATUS_SUBMITTED,)
+                )
+                for row in cursor.fetchall():
+                    accounts.append({
+                        'id': row[0],
+                        'register_time': row[1],
+                        'username': row[2],
+                        'password': row[3],
+                        'security_email': row[4],
+                        'status': row[5],
+                        'activation_link': row[6]
+                    })
+        
+        # 使用LinkExtractor提取链接
+        extractor = controller.extractor
+        success_count = 0
+        error_count = 0
+        sem = asyncio.Semaphore(max_workers)
+
+        async def handle_account(account):
+            nonlocal success_count, error_count
+            try:
+                async with sem:
+                    controller.db_manager.log_operation(
+                        account['username'],
+                        "extract_link_background",
+                        "processing",
+                        f"任务ID: {task_id}"
+                    )
+                    loop = asyncio.get_running_loop()
+                    link = await loop.run_in_executor(None, extractor.extract_link, account)
+                    if link:
+                        success_count += 1
+                    else:
+                        error_count += 1
+                    await asyncio.sleep(1)
+            except Exception as e:
+                error_count += 1
+                error_msg = str(e)
+                controller.db_manager.update_account_status(
+                    account['id'],
+                    STATUS_SUBMITTED,
+                    notes=f"后台任务异常: {error_msg[:100]}"
+                )
+                controller.db_manager.log_operation(
+                    account['username'],
+                    "extract_link_background",
+                    "error",
+                    error_msg[:200]
+                )
+
+        tasks_list = [handle_account(account) for account in accounts]
+        await asyncio.gather(*tasks_list)
+
+        running_tasks[task_id] = {
+            "status": "completed",
+            "success_count": success_count,
+            "error_count": error_count,
+            "total": len(accounts)
+        }
+    except Exception as e:
+        logger.error(f"后台提取任务 {task_id} 执行失败: {str(e)}")
+        running_tasks[task_id] = {
+            "status": "failed",
+            "error": str(e)
+        }
+
+# API路由
+@app.get("/")
+async def root():
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    index_path = os.path.join(current_dir, "index.html")
+    if os.path.exists(index_path):
+        return FileResponse(index_path)
+    return {"message": "index.html not found in the current directory"}
+
+@app.get("/accounts", response_model=AccountsResponse, dependencies=[Depends(verify_token)])
+async def get_accounts(
+    status: Optional[int] = None,
+    page: int = Query(1, ge=1),
+    per_page: int = Query(10, ge=1, le=100),
+    search: Optional[str] = None,
+    register_time_start: Optional[str] = None,
+    register_time_end: Optional[str] = None,
+    id_min: Optional[int] = None,
+    id_max: Optional[int] = None,
+    has_activation_link: Optional[str] = None,
+    used: Optional[int] = Query(None)
+):
+    """获取账号列表，支持多条件筛选"""
+    offset = (page - 1) * per_page
+    try:
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            query_conditions = []
+            query_params = []
+            if status is not None:
+                query_conditions.append("status = ?")
+                query_params.append(status)
+            if search:
+                query_conditions.append("(username LIKE ? OR security_email LIKE ? OR notes LIKE ? OR activation_link LIKE ?)")
+                search_param = f"%{search}%"
+                query_params.extend([search_param, search_param, search_param, search_param])
+            if register_time_start:
+                query_conditions.append("register_time >= ?")
+                query_params.append(register_time_start)
+            if register_time_end:
+                query_conditions.append("register_time <= ?")
+                query_params.append(register_time_end)
+            if id_min:
+                query_conditions.append("id >= ?")
+                query_params.append(id_min)
+            if id_max:
+                query_conditions.append("id <= ?")
+                query_params.append(id_max)
+            if has_activation_link == 'yes':
+                query_conditions.append("activation_link IS NOT NULL AND activation_link != ''")
+            elif has_activation_link == 'no':
+                query_conditions.append("(activation_link IS NULL OR activation_link = '')")
+            if used is not None and used != '':
+                query_conditions.append("used = ?")
+                query_params.append(int(used))
+            if query_conditions:
+                where_clause = "WHERE " + " AND ".join(query_conditions)
+            else:
+                where_clause = ""
+            count_query = f"SELECT COUNT(*) FROM accounts {where_clause}"
+            cursor.execute(count_query, query_params)
+            total = cursor.fetchone()[0]
+            data_query = f"""
+            SELECT id, register_time, username, password, security_email, status, activation_link, updated_at, notes, used 
+            FROM accounts 
+            {where_clause}
+            ORDER BY id DESC
+            LIMIT ? OFFSET ?
+            """
+            query_params_data = query_params + [per_page, offset]
+            cursor.execute(data_query, query_params_data)
+            accounts = []
+            for row in cursor.fetchall():
+                accounts.append(AccountItem(
+                    id=row[0],
+                    register_time=row[1],
+                    username=row[2],
+                    password=row[3],
+                    security_email=row[4],
+                    status=row[5],
+                    activation_link=row[6],
+                    updated_at=row[7],
+                    notes=row[8],
+                    used=row[9] if len(row) > 9 else 0
+                ))
+            return AccountsResponse(accounts=accounts, total=total)
+    except Exception as e:
+        logger.error(f"获取账号列表出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"获取账号列表出错: {str(e)}")
+
+@app.get("/accounts/{account_id}", response_model=AccountItem, dependencies=[Depends(verify_token)])
+async def get_account(account_id: int):
+    """获取单个账号详情"""
+    try:
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            cursor.execute(
+                "SELECT id, register_time, username, password, security_email, status, activation_link, updated_at, notes FROM accounts WHERE id = ?",
+                (account_id,)
+            )
+            row = cursor.fetchone()
+            
+            if not row:
+                raise HTTPException(status_code=404, detail=f"未找到ID为{account_id}的账号")
+                
+            return AccountItem(
+                id=row[0],
+                register_time=row[1],
+                username=row[2],
+                password=row[3],
+                security_email=row[4],
+                status=row[5],
+                activation_link=row[6],
+                updated_at=row[7],
+                notes=row[8]
+            )
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"获取账号详情出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"获取账号详情出错: {str(e)}")
+
+@app.post("/accounts/{account_id}/status", response_model=AccountItem, dependencies=[Depends(verify_token)])
+async def update_account_status(account_id: int, status_update: StatusUpdateRequest):
+    """更新账号状态"""
+    try:
+        username = None
+        updated_account = None
+        
+        # 使用锁进行数据库操作
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            
+            # 先检查账号是否存在
+            cursor.execute("SELECT username FROM accounts WHERE id = ?", (account_id,))
+            result = cursor.fetchone()
+            if not result:
+                raise HTTPException(status_code=404, detail=f"未找到ID为{account_id}的账号")
+            
+            username = result[0]
+            
+            # 直接在锁内执行更新操作，避免嵌套锁
+            if status_update.activation_link and status_update.notes:
+                cursor.execute('''
+                UPDATE accounts 
+                SET status = ?, activation_link = ?, notes = ?, updated_at = datetime('now', 'localtime')
+                WHERE id = ?
+                ''', (status_update.status, status_update.activation_link, status_update.notes, account_id))
+            elif status_update.activation_link:
+                cursor.execute('''
+                UPDATE accounts 
+                SET status = ?, activation_link = ?, updated_at = datetime('now', 'localtime')
+                WHERE id = ?
+                ''', (status_update.status, status_update.activation_link, account_id))
+            elif status_update.notes:
+                cursor.execute('''
+                UPDATE accounts 
+                SET status = ?, notes = ?, updated_at = datetime('now', 'localtime')
+                WHERE id = ?
+                ''', (status_update.status, status_update.notes, account_id))
+            else:
+                cursor.execute('''
+                UPDATE accounts 
+                SET status = ?, updated_at = datetime('now', 'localtime')
+                WHERE id = ?
+                ''', (status_update.status, account_id))
+            
+            # 提交事务
+            controller.db_manager.conn.commit()
+            
+            # 返回更新后的账号
+            cursor.execute(
+                "SELECT id, register_time, username, password, security_email, status, activation_link, updated_at, notes FROM accounts WHERE id = ?",
+                (account_id,)
+            )
+            row = cursor.fetchone()
+            
+            updated_account = AccountItem(
+                id=row[0],
+                register_time=row[1],
+                username=row[2],
+                password=row[3],
+                security_email=row[4],
+                status=row[5],
+                activation_link=row[6],
+                updated_at=row[7],
+                notes=row[8]
+            )
+        
+        # 锁外记录操作日志，避免死锁
+        if username:
+            controller.db_manager.log_operation(
+                username, 
+                "update_status", 
+                "success", 
+                f"手动更新状态为: {status_update.status}"
+            )
+            
+        return updated_account
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"更新账号状态出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"更新账号状态出错: {str(e)}")
+
+@app.post("/accounts/{account_id}/toggle-used", dependencies=[Depends(verify_token)])
+async def toggle_account_used(account_id: int):
+    """切换账号的used状态"""
+    try:
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            cursor.execute("SELECT used FROM accounts WHERE id = ?", (account_id,))
+            row = cursor.fetchone()
+            if not row:
+                raise HTTPException(status_code=404, detail=f"未找到ID为{account_id}的账号")
+            current = row[0] or 0
+            new_value = 0 if current else 1
+            cursor.execute("UPDATE accounts SET used = ?, updated_at = datetime('now', 'localtime') WHERE id = ?", (new_value, account_id))
+            controller.db_manager.conn.commit()
+        return {"id": account_id, "used": new_value}
+    except Exception as e:
+        logger.error(f"切换账号used状态出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"切换账号used状态出错: {str(e)}")
+
+@app.post("/accounts/batch-toggle-used", dependencies=[Depends(verify_token)])
+async def batch_toggle_used(req: BatchToggleUsedRequest = Body(...)):
+    """批量修改账号的used状态"""
+    try:
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            if not req.ids:
+                raise HTTPException(status_code=400, detail="未指定账号ID")
+            cursor.execute(f"UPDATE accounts SET used = ?, updated_at = datetime('now', 'localtime') WHERE id IN ({','.join(['?']*len(req.ids))})", [req.used, *req.ids])
+            controller.db_manager.conn.commit()
+        return {"updated": cursor.rowcount}
+    except Exception as e:
+        logger.error(f"批量切换账号used状态出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"批量切换账号used状态出错: {str(e)}")
+
+@app.delete("/accounts/{account_id}", dependencies=[Depends(verify_token)])
+async def delete_account(account_id: int):
+    logger.info(f"收到删除账号请求: {account_id}")
+    try:
+        with controller.db_manager.lock:
+            logger.info(f"已获取数据库锁，准备查询账号: {account_id}")
+            cursor = controller.db_manager.conn.cursor()
+            cursor.execute("SELECT username FROM accounts WHERE id = ?", (account_id,))
+            row = cursor.fetchone()
+            if not row:
+                logger.warning(f"未找到账号: {account_id}")
+                raise HTTPException(status_code=404, detail=f"未找到ID为{account_id}的账号")
+            username = row[0]
+            logger.info(f"准备删除账号: {account_id}, 用户名: {username}")
+            cursor.execute("DELETE FROM accounts WHERE id = ?", (account_id,))
+            controller.db_manager.conn.commit()
+            logger.info(f"账号已删除: {account_id}")
+        # 注意：操作日志写入要放到锁外，避免死锁
+        controller.db_manager.log_operation(username, "delete_account", "success", f"删除账号ID: {account_id}")
+        logger.info(f"删除账号流程结束: {account_id}")
+        return {"message": f"账号 {account_id} 已删除"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"删除账号出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"删除账号出错: {str(e)}")
+
+@app.post("/submit", response_model=Dict, dependencies=[Depends(verify_token)])
+async def submit_emails(request: SubmitRequest, background_tasks: BackgroundTasks):
+    """提交邮箱到JetBrains（异步任务）"""
+    try:
+        task_id = f"submit_{datetime.now().strftime('%Y%m%d%H%M%S')}_{len(running_tasks) + 1}"
+        
+        # 设置初始任务状态
+        running_tasks[task_id] = {
+            "status": "running",
+            "type": "submit",
+            "start_time": datetime.now().isoformat(),
+            "account_ids": request.account_ids,
+            "max_workers": request.max_workers
+        }
+        
+        # 启动后台任务
+        background_tasks.add_task(
+            process_submit_task,
+            task_id=task_id,
+            account_ids=request.account_ids,
+            max_workers=request.max_workers,
+            proxy=request.proxy
+        )
+        
+        return {
+            "task_id": task_id,
+            "message": "邮箱提交任务已启动",
+            "status": "running"
+        }
+        
+    except Exception as e:
+        logger.error(f"启动提交任务出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"启动提交任务出错: {str(e)}")
+
+@app.post("/extract", response_model=Dict, dependencies=[Depends(verify_token)])
+async def extract_links(request: ExtractRequest, background_tasks: BackgroundTasks):
+    """从邮箱提取激活链接（异步任务）"""
+    try:
+        task_id = f"extract_{datetime.now().strftime('%Y%m%d%H%M%S')}_{len(running_tasks) + 1}"
+        
+        # 设置初始任务状态
+        running_tasks[task_id] = {
+            "status": "running",
+            "type": "extract",
+            "start_time": datetime.now().isoformat(),
+            "account_ids": request.account_ids,
+            "max_workers": request.max_workers
+        }
+        
+        # 启动后台任务
+        background_tasks.add_task(
+            process_extract_task,
+            task_id=task_id,
+            account_ids=request.account_ids,
+            max_workers=request.max_workers
+        )
+        
+        return {
+            "task_id": task_id,
+            "message": "链接提取任务已启动",
+            "status": "running"
+        }
+        
+    except Exception as e:
+        logger.error(f"启动提取任务出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"启动提取任务出错: {str(e)}")
+
+@app.get("/tasks/{task_id}", dependencies=[Depends(verify_token)])
+async def get_task_status(task_id: str):
+    """获取任务状态"""
+    if task_id not in running_tasks:
+        raise HTTPException(status_code=404, detail=f"未找到任务ID: {task_id}")
+    
+    return running_tasks[task_id]
+
+@app.get("/tasks", dependencies=[Depends(verify_token)])
+async def get_all_tasks():
+    """获取所有任务状态"""
+    return running_tasks
+
+@app.post("/import", response_model=ImportResponse, dependencies=[Depends(verify_token)])
+async def import_accounts(file: UploadFile = File(...)):
+    """从上传的文件导入账号"""
+    try:
+        content = await file.read()
+        # 假设文件是utf-8编码文本
+        text = content.decode("utf-8")
+        # 将内容写入临时文件，再用原有的import_data逻辑导入
+        import tempfile
+        with tempfile.NamedTemporaryFile(delete=False, mode="w", encoding="utf-8", suffix=".txt") as tmp:
+            tmp.write(text)
+            tmp_path = tmp.name
+        imported_count = controller.import_data(tmp_path)
+        # 获取总账号数
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            cursor.execute("SELECT COUNT(*) FROM accounts")
+            total = cursor.fetchone()[0]
+        # 删除临时文件
+        import os
+        os.remove(tmp_path)
+        return ImportResponse(
+            imported_count=imported_count,
+            total_accounts=total
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"导入账号出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"导入账号出错: {str(e)}")
+
+@app.post("/export", dependencies=[Depends(verify_token)])
+async def export_accounts(request: dict = Body(...)):
+    """导出账号到文件并下载到本地，支持所有筛选条件"""
+    try:
+        import io
+        buffer = io.StringIO()
+        # 动态拼接筛选条件
+        query_conditions = []
+        query_params = []
+        status = request.get('status', None)
+        used = request.get('used', None)
+        search = request.get('search', None)
+        has_activation_link = request.get('has_activation_link', None)
+        id_min = request.get('id_min', None)
+        id_max = request.get('id_max', None)
+        register_time_start = request.get('register_time_start', None)
+        register_time_end = request.get('register_time_end', None)
+        if status is not None and status != '':
+            query_conditions.append("status = ?")
+            query_params.append(status)
+        if search:
+            query_conditions.append("(username LIKE ? OR security_email LIKE ? OR notes LIKE ? OR activation_link LIKE ?)")
+            search_param = f"%{search}%"
+            query_params.extend([search_param, search_param, search_param, search_param])
+        if register_time_start:
+            query_conditions.append("register_time >= ?")
+            query_params.append(register_time_start)
+        if register_time_end:
+            query_conditions.append("register_time <= ?")
+            query_params.append(register_time_end)
+        if id_min:
+            query_conditions.append("id >= ?")
+            query_params.append(id_min)
+        if id_max:
+            query_conditions.append("id <= ?")
+            query_params.append(id_max)
+        if has_activation_link == 'yes':
+            query_conditions.append("activation_link IS NOT NULL AND activation_link != ''")
+        elif has_activation_link == 'no':
+            query_conditions.append("(activation_link IS NULL OR activation_link = '')")
+        if used is not None and used != '':
+            query_conditions.append("used = ?")
+            query_params.append(int(used))
+        if query_conditions:
+            where_clause = "WHERE " + " AND ".join(query_conditions)
+        else:
+            where_clause = ""
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            cursor.execute(f"""
+                SELECT activation_link 
+                FROM accounts 
+                {where_clause}
+                ORDER BY id DESC
+            """, query_params)
+            for row in cursor.fetchall():
+                if row[0]:
+                    buffer.write(f"{row[0]}\n")
+        buffer.seek(0)
+        content = buffer.getvalue().encode('utf-8')
+        byte_io = io.BytesIO(content)
+        filename = request.get('filename', 'export_accounts.txt')
+        headers = {
+            'Content-Disposition': f'attachment; filename="{filename}"'
+        }
+        return StreamingResponse(
+            byte_io, 
+            media_type="text/plain",
+            headers=headers
+        )
+    except Exception as e:
+        logger.error(f"导出账号出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"导出账号出错: {str(e)}")
+
+@app.get("/statistics", response_model=StatusCounts, dependencies=[Depends(verify_token)])
+async def get_statistics():
+    """获取账号统计信息"""
+    try:
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            
+            # 获取总账号数
+            cursor.execute("SELECT COUNT(*) FROM accounts")
+            total = cursor.fetchone()[0]
+            
+            # 获取各状态账号数
+            cursor.execute("SELECT COUNT(*) FROM accounts WHERE status = ?", (STATUS_PENDING,))
+            pending = cursor.fetchone()[0]
+            
+            cursor.execute("SELECT COUNT(*) FROM accounts WHERE status = ?", (STATUS_SUBMITTED,))
+            submitted = cursor.fetchone()[0]
+            
+            cursor.execute("SELECT COUNT(*) FROM accounts WHERE status = ?", (STATUS_FAILED,))
+            failed = cursor.fetchone()[0]
+            
+            cursor.execute("SELECT COUNT(*) FROM accounts WHERE status = ?", (STATUS_LINK_EXTRACTED,))
+            link_extracted = cursor.fetchone()[0]
+            
+            cursor.execute("SELECT COUNT(*) FROM accounts WHERE used = 0")
+            unused = cursor.fetchone()[0]
+            
+            return StatusCounts(
+                total=total,
+                pending=pending,
+                submitted=submitted,
+                failed=failed,
+                link_extracted=link_extracted,
+                unused=unused
+            )
+            
+    except Exception as e:
+        logger.error(f"获取统计信息出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"获取统计信息出错: {str(e)}")
+
+@app.post("/reset-failed", dependencies=[Depends(verify_token)])
+async def reset_failed_accounts():
+    """将失败的账号状态重置为未提交状态"""
+    try:
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            cursor.execute(
+                "UPDATE accounts SET status = ?, notes = 'Reset from failed status', updated_at = datetime('now', 'localtime') WHERE status = ?",
+                (STATUS_PENDING, STATUS_FAILED)
+            )
+            controller.db_manager.conn.commit()
+            
+            # 获取重置的账号数
+            reset_count = cursor.rowcount
+            
+            return {"reset_count": reset_count, "message": f"已将{reset_count}个失败账号重置为未提交状态"}
+            
+    except Exception as e:
+        logger.error(f"重置失败账号出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"重置失败账号出错: {str(e)}")
+
+@app.get("/logs", dependencies=[Depends(verify_token)])
+async def get_logs(
+    username: Optional[str] = None,
+    operation: Optional[str] = None,
+    status: Optional[str] = None,
+    page: int = Query(1, ge=1),
+    per_page: int = Query(20, ge=1, le=100)
+):
+    """获取操作日志"""
+    offset = (page - 1) * per_page
+    
+    try:
+        with controller.db_manager.lock:
+            cursor = controller.db_manager.conn.cursor()
+            
+            # 构建查询条件
+            query_conditions = []
+            query_params = []
+            
+            if username:
+                query_conditions.append("username LIKE ?")
+                query_params.append(f"%{username}%")
+            
+            if operation:
+                query_conditions.append("operation = ?")
+                query_params.append(operation)
+            
+            if status:
+                query_conditions.append("status = ?")
+                query_params.append(status)
+            
+            # 构建完整查询
+            if query_conditions:
+                where_clause = "WHERE " + " AND ".join(query_conditions)
+            else:
+                where_clause = ""
+            
+            # 计算总记录数
+            count_query = f"SELECT COUNT(*) FROM operation_logs {where_clause}"
+            cursor.execute(count_query, query_params)
+            total = cursor.fetchone()[0]
+            
+            # 获取分页数据
+            data_query = f"""
+            SELECT id, username, operation, status, message, created_at 
+            FROM operation_logs 
+            {where_clause}
+            ORDER BY id DESC
+            LIMIT ? OFFSET ?
+            """
+            
+            # 添加分页参数
+            query_params.extend([per_page, offset])
+            cursor.execute(data_query, query_params)
+            
+            logs = []
+            for row in cursor.fetchall():
+                logs.append({
+                    "id": row[0],
+                    "username": row[1],
+                    "operation": row[2],
+                    "status": row[3],
+                    "message": row[4],
+                    "created_at": row[5]
+                })
+            
+            return {"logs": logs, "total": total}
+            
+    except Exception as e:
+        logger.error(f"获取操作日志出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"获取操作日志出错: {str(e)}")
+
+@app.post("/login")
+async def login(data: dict = Body(...)):
+    password = data.get("password", "")
+    if password == ADMIN_PASSWORD:
+        return {"token": ADMIN_PASSWORD}
+    else:
+        raise HTTPException(status_code=401, detail="密码错误")
+
+if __name__ == "__main__":
+    # 运行FastAPI应用
+    uvicorn.run("api_server:app", host="0.0.0.0", port=8000, reload=True)

index.html

@@ -0,0 +1,1606 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>JetBrains激活链接管理系统</title>
+  <!-- 使用CDN引入Vue 3和Element Plus，指定固定版本 -->
+  <link rel="stylesheet" href="https://unpkg.com/[email protected]/dist/index.css" />
+  <script src="https://unpkg.com/[email protected]/dist/vue.global.prod.js"></script>
+  <script src="https://unpkg.com/[email protected]"></script>
+  <script src="https://unpkg.com/@element-plus/[email protected]"></script>
+  <script src="https://unpkg.com/[email protected]/dist/axios.min.js"></script>
+  <style>
+    body {
+      margin: 0;
+      padding: 0;
+      font-family: "Helvetica Neue", Helvetica, "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", Arial, sans-serif;
+      -webkit-font-smoothing: antialiased;
+      -moz-osx-font-smoothing: grayscale;
+      background-color: #f5f7fa;
+      color: #303133;
+    }
+    .app-container {
+      padding: 8px;
+    }
+    .dashboard-card {
+      margin-bottom: 20px;
+      border-radius: 4px;
+      box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+      background-color: #fff;
+    }
+    .dashboard-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 10px 20px;
+      border-bottom: 1px solid #ebeef5;
+    }
+    .el-table .status-column {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    .el-table .status-0 {
+      color: #909399;
+    }
+    .el-table .status-1 {
+      color: #409EFF;
+    }
+    .el-table .status-2 {
+      color: #F56C6C;
+    }
+    .el-table .status-3 {
+      color: #67C23A;
+    }
+    .operation-btn {
+      margin-right: 5px;
+    }
+    .statistics-card {
+      text-align: center;
+      padding: 20px;
+    }
+    .statistics-value {
+      font-size: 36px;
+      font-weight: bold;
+    }
+    .statistics-label {
+      font-size: 14px;
+      color: #909399;
+    }
+    .task-card {
+      margin-bottom: 15px;
+    }
+    .copy-button {
+      margin-left: 5px;
+    }
+    .el-tag {
+      margin: 2px;
+    }
+    .tab-container {
+      padding: 15px;
+    }
+    .sr-only {
+      position: absolute;
+      width: 1px;
+      height: 1px;
+      padding: 0;
+      margin: -1px;
+      overflow: hidden;
+      clip: rect(0, 0, 0, 0);
+      white-space: nowrap;
+      border-width: 0;
+    }
+    .required-field::after {
+      content: ' *';
+      color: #F56C6C;
+    }
+    .el-table .id-column,
+    .el-table .register-time-column,
+    .el-table .username-column,
+    .el-table .email-column {
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    .el-table .email-column {
+      max-width: 250px;
+    }
+    /* 调试样式 - 显示表格边框和背景色 */
+    .el-table {
+      border: 1px solid #dcdfe6;
+    }
+    .el-table th {
+      background-color: #f5f7fa !important;
+      color: #606266;
+      font-weight: bold;
+      text-align: center !important;
+    }
+    .el-table td {
+      text-align: center;
+    }
+    /* 确保ID列和时间列有足够的宽度 */
+    .el-table .id-column {
+      min-width: 80px !important;
+      width: 80px !important;
+    }
+    .el-table .register-time-column {
+      min-width: 180px !important;
+      width: 180px !important;
+    }
+    .el-table .username-column {
+      min-width: 250px !important;
+    }
+    .el-table .email-column {
+      min-width: 180px !important;
+    }
+    /* 必填字段标记 */
+    .required::after {
+      content: '*';
+      color: #F56C6C;
+      margin-left: 4px;
+    }
+    @media (max-width: 900px) {
+      .app-container {
+        padding: 2px !important;
+      }
+      .dashboard-card {
+        margin-bottom: 8px;
+        padding: 0 2px;
+      }
+      .statistics-card {
+        border-radius: 10px;
+        box-shadow: 0 2px 8px #eee;
+        padding: 10px 0;
+        text-align: center !important;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      }
+      .statistics-value {
+        font-size: 28px;
+        text-align: center !important;
+        width: 100%;
+        margin: 0 auto;
+      }
+      .statistics-label {
+        font-size: 16px;
+        text-align: center !important;
+        width: 100%;
+        margin: 0 auto;
+      }
+      .tab-container {
+        padding: 4px;
+      }
+      .el-row.filter-row {
+        margin: 0 -2px;
+      }
+      .el-col.filter-col {
+        margin-bottom: 4px;
+        padding: 0 2px;
+      }
+      .el-table {
+        border-radius: 6px;
+        box-shadow: 0 1px 4px #eee;
+        font-size: 15px;
+      }
+      .el-table th, .el-table td {
+        padding-left: 2px;
+        padding-right: 2px;
+      }
+      .el-pagination {
+        font-size: 15px;
+      }
+    }
+  </style>
+</head>
+<body>
+  <!--- /> 标签改为标准的成对闭合形式，否则显示将不正常-->
+  <div id="app" class="app-container">
+    <el-container>
+      <el-header style="height: auto; padding: 0; margin-bottom: 20px;">
+        <div class="dashboard-card">
+          <div class="dashboard-header">
+            <h2>JetBrains激活链接管理系统</h2>
+            <div>
+              <el-button type="primary" @click="showImportDialog">导入数据</el-button>
+              <el-button type="success" @click="showExportDialog">导出数据</el-button>
+              <el-button type="danger" @click="resetFailedAccounts">重置失败账号</el-button>
+              <el-button type="warning" @click="logout" style="margin-left: 10px;">退出登录</el-button>
+            </div>
+          </div>
+        </div>
+      </el-header>
+      
+      <el-main>
+        <!-- 统计信息卡片  /> 标签改为标准的成对闭合形式，否则显示将不正常 -->
+        <el-row :gutter="20">
+          <el-col :span="4">
+            <el-card shadow="hover" class="statistics-card">
+              <div class="statistics-value">{{ statistics.total }}</div>
+              <div class="statistics-label">总数</div>
+            </el-card>
+          </el-col>
+          <!-- <el-col :span="5">
+            <el-card shadow="hover" class="statistics-card" style="background-color: #f0f9eb;">
+              <div class="statistics-value" style="color: #67C23A;">{{ statistics.link_extracted }}</div>
+              <div class="statistics-label">链接</div>
+            </el-card>
+          </el-col> -->
+          <el-col :span="5">
+            <el-card shadow="hover" class="statistics-card" style="background-color: #f9f9e3;">
+              <div class="statistics-value" style="color: #e6a23c;">{{ statistics.unused }}</div>
+              <div class="statistics-label">未用</div>
+            </el-card>
+          </el-col>
+          <el-col :span="5">
+            <el-card shadow="hover" class="statistics-card" style="background-color: #ecf5ff;">
+              <div class="statistics-value" style="color: #409EFF;">{{ statistics.submitted }}</div>
+              <div class="statistics-label">提交</div>
+            </el-card>
+          </el-col>
+          <el-col :span="5">
+            <el-card shadow="hover" class="statistics-card" style="background-color: #fef0f0;">
+              <div class="statistics-value" style="color: #F56C6C;">{{ statistics.failed }}</div>
+              <div class="statistics-label">失败</div>
+            </el-card>
+          </el-col>
+          <el-col :span="5">
+            <el-card shadow="hover" class="statistics-card" style="background-color: #f4f4f5;">
+              <div class="statistics-value" style="color: #909399;">{{ statistics.pending }}</div>
+              <div class="statistics-label">未取</div>
+            </el-card>
+          </el-col>
+        </el-row>
+
+        <!-- 主要标签页 -->
+        <el-tabs type="border-card" v-model="activeTab" @tab-click="handleTabClick">
+          <!-- 账号管理标签页 -->
+          <el-tab-pane label="账号管理" name="accounts">
+            <div class="tab-container">
+              <div style="margin-bottom: 20px;">
+                <el-row :gutter="10" class="filter-row" style="flex-wrap: nowrap; display: flex;">
+                  <el-col :span="3" class="filter-col" style="min-width: 120px;">
+                    <el-select v-model="accountsFilter.status" placeholder="选择状态" clearable style="width: 100%;" @change="handleStatusChange">
+                      <el-option label="未提交" :value="0"></el-option>
+                      <el-option label="已提交" :value="1"></el-option>
+                      <el-option label="提交失败" :value="2"></el-option>
+                      <el-option label="已提取链接" :value="3"></el-option>
+                    </el-select>
+                  </el-col>
+                  <el-col :span="3" class="filter-col" style="min-width: 140px;">
+                    <el-date-picker v-model="accountsFilter.registerTimeStart" type="date" placeholder="注册起始日期" style="width: 100%;" format="YYYY-MM-DD" value-format="YYYY-MM-DD" clearable></el-date-picker>
+                  </el-col>
+                  <el-col :span="3" class="filter-col" style="min-width: 140px;">
+                    <el-date-picker v-model="accountsFilter.registerTimeEnd" type="date" placeholder="注册结束日期" style="width: 100%;" format="YYYY-MM-DD" value-format="YYYY-MM-DD" clearable></el-date-picker>
+                  </el-col>
+                  <el-col :span="2" class="filter-col" style="min-width: 90px;">
+                    <el-input v-model="accountsFilter.idMin" placeholder="最小ID" clearable></el-input>
+                  </el-col>
+                  <el-col :span="2" class="filter-col" style="min-width: 90px;">
+                    <el-input v-model="accountsFilter.idMax" placeholder="最大ID" clearable></el-input>
+                  </el-col>
+                  <el-col :span="3" class="filter-col" style="min-width: 120px;">
+                    <el-select v-model="accountsFilter.hasActivationLink" placeholder="激活链接" clearable style="width: 100%;">
+                      <el-option label="全部" value=""></el-option>
+                      <el-option label="有激活链接" value="yes"></el-option>
+                      <el-option label="无激活链接" value="no"></el-option>
+                    </el-select>
+                  </el-col>
+                  <el-col :span="3" class="filter-col" style="min-width: 120px;">
+                    <el-select v-model="accountsFilter.used" placeholder="使用状态" clearable style="width: 100%;">
+                      <el-option label="全部" :value="''"></el-option>
+                      <el-option label="未被使用" :value="0"></el-option>
+                      <el-option label="已被使用" :value="1"></el-option>
+                    </el-select>
+                  </el-col>
+                  <el-col :span="4" class="filter-col" style="min-width: 160px;">
+                    <el-input v-model="accountsFilter.search" placeholder="邮箱/备注" clearable></el-input>
+                  </el-col>
+                </el-row>
+              </div>
+
+              <el-row :gutter="20" style="margin-bottom: 10px;">
+                <el-col :span="24" style="text-align: right;">
+                  <el-button type="primary" :disabled="selectedAccounts.length === 0" @click="batchToggleUsed(1)">
+                    批量标记为已使用
+                  </el-button>
+                  <el-button type="info" :disabled="selectedAccounts.length === 0" @click="batchToggleUsed(0)">
+                    批量标记为未使用
+                  </el-button>
+                </el-col>
+              </el-row>
+
+              <el-table 
+                :data="accounts" 
+                style="width: 100%;overflow-x:auto;"
+                v-loading="loading.accounts"
+                @selection-change="handleSelectionChange"
+                border
+                stripe
+                highlight-current-row
+              >
+                <el-table-column type="selection" width="50"> </el-table-column>
+                <el-table-column label="ID" width="80" sortable>
+                  <template #default="scope">
+                    {{ scope.row.id || '-' }}
+                  </template>
+                </el-table-column>
+                <el-table-column label="注册时间" width="180" sortable>
+                  <template #default="scope">
+                    {{ scope.row.register_time || '-' }}
+                  </template>
+                </el-table-column>
+                <el-table-column label="用户名" min-width="250" show-overflow-tooltip>
+                  <template #default="scope">
+                    {{ scope.row.username || '-' }}
+                  </template>
+                </el-table-column>
+                <el-table-column label="状态" width="120">
+                  <template #default="scope">
+                    <el-tag :type="getStatusType(scope.row.status)" size="small">
+                      {{ getStatusText(scope.row.status) }}
+                    </el-tag>
+                  </template>
+                </el-table-column>
+                <el-table-column label="激活链接" min-width="300">
+                  <template #default="scope">
+                    <div v-if="scope.row.activation_link" style="display: flex; align-items: center;">
+                      <el-tooltip :content="scope.row.activation_link" placement="top" effect="light">
+                        <span style="white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 200px;">
+                          {{ scope.row.activation_link }}
+                        </span>
+                      </el-tooltip>
+                      <el-button
+                        size="small"
+                        type="primary"
+                        class="copy-button"
+                        @click="copyToClipboard(scope.row.activation_link, scope.row)"
+                      >
+                        复制
+                      </el-button>
+                    </div>
+                    <span v-else>-</span>
+                  </template>
+                </el-table-column>
+                <el-table-column label="已被使用" width="100">
+                  <template #default="scope">
+                    <el-tag :type="scope.row.used ? 'success' : 'info'" @click="toggleAccountUsed(scope.row)" style="cursor:pointer;">
+                      {{ scope.row.used ? '✔ 已使用' : '未使用' }}
+                    </el-tag>
+                  </template>
+                </el-table-column>
+                <el-table-column label="操作" width="250" fixed="right">
+                  <template #default="scope">
+                    <el-button
+                      size="small"
+                      type="primary"
+                      @click="submitSingleAccount(scope.row)"
+                      :disabled="scope.row.status === 1 || scope.row.status === 3"
+                    >
+                      提交
+                    </el-button>
+                    <el-button
+                      size="small"
+                      type="success"
+                      @click="extractSingleAccount(scope.row)"
+                      :disabled="scope.row.status !== 1"
+                    >
+                      提取
+                    </el-button>
+                    <el-button
+                      size="small"
+                      @click="viewAccountDetails(scope.row)"
+                    >
+                      详情
+                    </el-button>
+                    <el-button
+                      size="small"
+                      type="danger"
+                      @click="deleteAccount(scope.row)"
+                    >
+                      删除
+                    </el-button>
+                  </template>
+                </el-table-column>
+              </el-table>
+              
+              <div style="margin-top: 20px; display: flex; justify-content: center;">
+                <el-pagination
+                  v-model:current-page="pagination.current"
+                  v-model:page-size="pagination.pageSize"
+                  :page-sizes="[10, 20, 50, 100]"
+                  layout="total, sizes, prev, pager, next, jumper"
+                  :total="pagination.total"
+                  @size-change="handleSizeChange"
+                  @current-change="handleCurrentChange"
+                />
+              </div>
+            </div>
+          </el-tab-pane>
+          
+          <!-- 任务管理标签页 -->
+          <el-tab-pane label="任务管理" name="tasks">
+            <div class="tab-container">
+              <el-button type="primary" @click="loadTasks" style="margin-bottom: 20px;">刷新任务列表</el-button>
+              
+              <el-timeline>
+                <el-timeline-item
+                  v-for="(task, id) in tasks"
+                  :key="id"
+                  :type="getTaskStatusType(task.status)"
+                  :icon="getTaskStatusIcon(task.status)"
+                  :timestamp="task.start_time"
+                >
+                  <el-card class="task-card">
+                    <div style="display: flex; justify-content: space-between; align-items: center;">
+                      <div>
+                        <span style="font-weight: bold;">{{ getTaskTypeText(task.type) }} - {{ id }}</span>
+                        <el-tag size="small" style="margin-left: 10px;" :type="getTaskStatusType(task.status)">
+                          {{ getTaskStatusText(task.status) }}
+                        </el-tag>
+                      </div>
+                      <div v-if="task.status === 'completed'">
+                        <span style="margin-right: 10px;">成功: {{ task.success_count || 0 }}</span>
+                        <span>失败: {{ task.error_count || 0 }}</span>
+                      </div>
+                    </div>
+                    <div v-if="task.error" style="color: #F56C6C; margin-top: 10px;">
+                      错误: {{ task.error }}
+                    </div>
+                    <div v-if="task.account_ids && task.account_ids.length > 0" style="margin-top: 10px;">
+                      <span>处理账号: {{ task.account_ids.length }}个</span>
+                    </div>
+                  </el-card>
+                </el-timeline-item>
+              </el-timeline>
+              
+              <div v-if="Object.keys(tasks).length === 0" style="text-align: center; padding: 30px;">
+                <el-empty description="暂无任务记录" />
+              </div>
+            </div>
+          </el-tab-pane>
+          
+          <!-- 操作日志标签页 -->
+          <el-tab-pane label="操作日志" name="logs">
+            <div class="tab-container">
+              <div style="margin-bottom: 20px;">
+                <el-row :gutter="20">
+                  <el-col :span="8">
+                    <el-input v-model="logsFilter.username" placeholder="用户名" clearable></el-input>
+                  </el-col>
+                  <el-col :span="8">
+                    <el-select v-model="logsFilter.operation" placeholder="操作类型" clearable style="width: 100%;">
+                      <el-option label="提交邮箱" value="submit_email"></el-option>
+                      <el-option label="提取链接" value="extract_link"></el-option>
+                      <el-option label="后台提交" value="submit_email_background"></el-option>
+                      <el-option label="后台提取" value="extract_link_background"></el-option>
+                      <el-option label="更新状态" value="update_status"></el-option>
+                    </el-select>
+                  </el-col>
+                  <el-col :span="8">
+                    <el-select v-model="logsFilter.status" placeholder="操作状态" clearable style="width: 100%;">
+                      <el-option label="成功" value="success"></el-option>
+                      <el-option label="失败" value="failed"></el-option>
+                      <el-option label="处理中" value="processing"></el-option>
+                      <el-option label="错误" value="error"></el-option>
+                    </el-select>
+                  </el-col>
+                </el-row>
+              </div>
+              
+              <el-table 
+                :data="logs" 
+                style="width: 100%"
+                v-loading="loading.logs"
+                border
+              >
+                <el-table-column label="ID" width="80">
+                  <template #default="scope">
+                    {{ scope.row.log_id || scope.row.id || '-' }}
+                  </template>
+                </el-table-column>
+                <el-table-column label="用户名" min-width="150">
+                  <template #default="scope">
+                    {{ scope.row.account_username || scope.row.username || '-' }}
+                  </template>
+                </el-table-column>
+                <el-table-column label="操作" width="180">
+                  <template #default="scope">
+                    <el-tag size="small">{{ getOperationText(scope.row.operation) }}</el-tag>
+                  </template>
+                </el-table-column>
+                <el-table-column label="状态" width="120">
+                  <template #default="scope">
+                    <el-tag :type="getLogStatusType(scope.row.status)" size="small">
+                      {{ scope.row.status }}
+                    </el-tag>
+                  </template>
+                </el-table-column>
+                <el-table-column label="消息" min-width="200">
+                  <template #default="scope">
+                    <el-tag size="small">{{ getMessageText(scope.row.message) }}</el-tag>
+                  </template>
+                </el-table-column>
+                <el-table-column label="时间" width="180">
+                  <template #default="scope">
+                    {{ scope.row.created_at || scope.row.timestamp || '-' }}
+                  </template>
+                </el-table-column>
+              </el-table>
+              
+              <div style="margin-top: 20px; display: flex; justify-content: center;">
+                <el-pagination
+                  v-model:current-page="logsPagination.current"
+                  v-model:page-size="logsPagination.pageSize"
+                  :page-sizes="[20, 50, 100]"
+                  layout="total, sizes, prev, pager, next, jumper"
+                  :total="logsPagination.total"
+                  @size-change="handleLogsSizeChange"
+                  @current-change="handleLogsCurrentChange"
+                />
+              </div>
+            </div>
+          </el-tab-pane>
+        </el-tabs>
+      </el-main>
+    </el-container>
+    
+    <!-- 导入数据对话框 -->
+    <el-dialog title="导入数据" v-model="dialogs.import" width="500px">
+      <el-form label-width="100px">
+        <el-form-item label="选择文件" required>
+          <input type="file" @change="handleImportFileChange" accept=".txt,.csv" />
+        </el-form-item>
+      </el-form>
+      <template #footer>
+        <span class="dialog-footer">
+          <el-button @click="dialogs.import = false">取消</el-button>
+          <el-button type="primary" @click="importAccounts" :loading="loading.import">导入</el-button>
+        </span>
+      </template>
+    </el-dialog>
+    
+    <!-- 导出数据对话框 -->
+    <el-dialog title="导出数据" v-model="dialogs.export" width="500px">
+      <el-form :model="exportForm" label-width="100px">
+        <el-form-item label="文件名">
+          <el-input v-model="exportForm.filename" placeholder="导出文件名"></el-input>
+        </el-form-item>
+      </el-form>
+      <template #footer>
+        <span class="dialog-footer">
+          <el-button @click="dialogs.export = false">取消</el-button>
+          <el-button type="primary" @click="exportAccounts" :loading="loading.export">导出</el-button>
+        </span>
+      </template>
+    </el-dialog>
+    
+    <!-- 账号详情对话框 -->
+    <el-dialog title="账号详情" v-model="dialogs.accountDetails" width="700px">
+      <el-descriptions v-if="currentAccount" :column="1" border>
+        <el-descriptions-item label="ID">{{ currentAccount.id }}</el-descriptions-item>
+        <el-descriptions-item label="注册时间">{{ currentAccount.register_time }}</el-descriptions-item>
+        <el-descriptions-item label="用户名">{{ currentAccount.username }}</el-descriptions-item>
+        <el-descriptions-item label="密码">{{ currentAccount.password }}</el-descriptions-item>
+        <el-descriptions-item label="密保邮箱">{{ currentAccount.security_email || '-' }}</el-descriptions-item>
+        <el-descriptions-item label="状态">
+          <el-tag :type="getStatusType(currentAccount.status)">
+            {{ getStatusText(currentAccount.status) }}
+          </el-tag>
+        </el-descriptions-item>
+        <el-descriptions-item label="激活链接">
+          <div v-if="currentAccount.activation_link" style="display: flex; align-items: center;">
+            <span style="word-break: break-all;">{{ currentAccount.activation_link }}</span>
+            <el-button
+              size="small"
+              type="primary"
+              class="copy-button"
+              @click="copyToClipboard(currentAccount.activation_link, currentAccount)"
+            >
+              复制
+            </el-button>
+          </div>
+          <span v-else>-</span>
+        </el-descriptions-item>
+        <el-descriptions-item label="更新时间">{{ currentAccount.updated_at || '-' }}</el-descriptions-item>
+        <el-descriptions-item label="备注">{{ currentAccount.notes || '-' }}</el-descriptions-item>
+      </el-descriptions>
+      
+      <div style="margin-top: 20px;">
+        <h3>更新状态</h3>
+        <el-form :model="statusUpdateForm" label-width="100px">
+          <el-form-item label="状态">
+            <el-select v-model="statusUpdateForm.status" placeholder="选择状态" style="width: 100%;">
+              <el-option label="未提交" :value="0"></el-option>
+              <el-option label="已提交" :value="1"></el-option>
+              <el-option label="提交失败" :value="2"></el-option>
+              <el-option label="已提取链接" :value="3"></el-option>
+            </el-select>
+          </el-form-item>
+          <el-form-item label="激活链接">
+            <el-input v-model="statusUpdateForm.activation_link" placeholder="可选"></el-input>
+          </el-form-item>
+          <el-form-item label="备注">
+            <el-input v-model="statusUpdateForm.notes" type="textarea" placeholder="可选"></el-input>
+          </el-form-item>
+        </el-form>
+      </div>
+      
+      <template #footer>
+        <span class="dialog-footer">
+          <el-button @click="dialogs.accountDetails = false">取消</el-button>
+          <el-button type="primary" @click="updateAccountStatus" :loading="loading.updateStatus">更新</el-button>
+        </span>
+      </template>
+    </el-dialog>
+    
+    <!-- 提交邮箱对话框 -->
+    <el-dialog title="提交邮箱" v-model="dialogs.submit" width="500px">
+      <el-form :model="submitForm" label-width="100px">
+        <el-form-item label="最大线程数">
+          <el-input-number v-model="submitForm.max_workers" :min="1" :max="10"></el-input-number>
+        </el-form-item>
+        <el-form-item label="代理服务器">
+          <el-input v-model="submitForm.proxy" placeholder="可选，例如：http://127.0.0.1:60060"></el-input>
+        </el-form-item>
+      </el-form>
+      <template #footer>
+        <span class="dialog-footer">
+          <el-button @click="dialogs.submit = false">取消</el-button>
+          <el-button type="primary" @click="confirmSubmit" :loading="loading.submit">提交</el-button>
+        </span>
+      </template>
+    </el-dialog>
+    
+    <!-- 提取链接对话框 -->
+    <el-dialog title="提取链接" v-model="dialogs.extract" width="500px">
+      <el-form :model="extractForm" label-width="100px">
+        <el-form-item label="最大线程数">
+          <el-input-number v-model="extractForm.max_workers" :min="1" :max="5"></el-input-number>
+        </el-form-item>
+      </el-form>
+      <template #footer>
+        <span class="dialog-footer">
+          <el-button @click="dialogs.extract = false">取消</el-button>
+          <el-button type="primary" @click="confirmExtract" :loading="loading.extract">提取</el-button>
+        </span>
+      </template>
+    </el-dialog>
+
+    <!-- 登录验证对话框 -->
+    <el-dialog title="登录验证" v-model="dialogs.login" width="350px" :close-on-click-modal="false" :show-close="false">
+      <el-form @submit.prevent="handleLogin">
+        <el-form-item label="密码">
+          <el-input v-model="loginForm.password" type="password" autocomplete="off" @keyup.enter="handleLogin"></el-input>
+        </el-form-item>
+      </el-form>
+      <template #footer>
+        <span class="dialog-footer">
+          <el-button type="primary" @click="handleLogin" :loading="loading.login">登录</el-button>
+        </span>
+      </template>
+    </el-dialog>
+  </div>
+
+  <script>
+    const { createApp, ref, reactive, onMounted, computed, nextTick, watch, onUnmounted } = Vue;
+    
+    // 后端API基础URL
+    const API_BASE_URL = 'http://192.168.2.8:8000';
+
+    const app = createApp({
+      setup() {
+        // 状态管理
+        const activeTab = ref('accounts');
+        const accounts = ref([]);
+        const selectedAccounts = ref([]);
+        const currentAccount = ref(null);
+        const tasks = ref({});
+        const logs = ref([]);
+        const statistics = reactive({
+          total: 0,
+          pending: 0,
+          submitted: 0,
+          failed: 0,
+          link_extracted: 0,
+          unused: 0
+        });
+        
+        // 任务轮询相关状态
+        const runningTaskPolls = reactive({});
+        
+        // 分页配置
+        const pagination = reactive({
+          current: 1,
+          pageSize: 10,
+          total: 0
+        });
+        
+        const logsPagination = reactive({
+          current: 1,
+          pageSize: 20,
+          total: 0
+        });
+        
+        // 过滤器
+        const accountsFilter = reactive({
+          status: null,
+          search: '',
+          registerTimeStart: '',
+          registerTimeEnd: '',
+          idMin: '',
+          idMax: '',
+          hasActivationLink: '', // '', 'yes', 'no'
+          used: '' // 新增
+        });
+        
+        const logsFilter = reactive({
+          username: '',
+          operation: '',
+          status: ''
+        });
+        
+        // 表单数据
+        const importForm = reactive({
+          filepath: 'user-4-21-success.txt'
+        });
+        
+        const exportForm = reactive({
+          filename: 'export_results.txt',
+          status: null
+        });
+        
+        const statusUpdateForm = reactive({
+          status: 0,
+          activation_link: '',
+          notes: ''
+        });
+        
+        const submitForm = reactive({
+          max_workers: 1,
+          proxy: ''
+        });
+        
+        const extractForm = reactive({
+          max_workers: 1
+        });
+        
+        const loginForm = reactive({ password: '' });
+
+        // 对话框控制
+        const dialogs = reactive({
+          import: false,
+          export: false,
+          accountDetails: false,
+          submit: false,
+          extract: false,
+          login: false
+        });
+        
+        // 加载状态
+        const loading = reactive({
+          accounts: false,
+          tasks: false,
+          logs: false,
+          statistics: false,
+          import: false,
+          export: false,
+          updateStatus: false,
+          submit: false,
+          extract: false,
+          login: false
+        });
+
+        // token管理
+        const getToken = () => {
+          return document.cookie.replace(/(?:(?:^|.*;\s*)token\s*\=\s*([^;]*).*$)|^.*$/, "$1");
+        };
+        const setToken = (token) => {
+          document.cookie = `token=${token};path=/;max-age=2592000`;
+        };
+        const clearToken = () => {
+          document.cookie = 'token=;path=/;expires=Thu, 01 Jan 1970 00:00:01 GMT;';
+        };
+
+        // axios请求拦截
+        axios.interceptors.request.use(config => {
+          const token = getToken();
+          if (token) config.headers.token = token;
+          return config;
+        });
+
+        // 初始化
+        onMounted(async () => {
+          if (!(await checkLogin())) return;
+          console.log('应用已加载，开始获取数据');
+          loadAccounts();
+          loadStatistics();
+          loadTasks();
+          
+          // 监听过滤器变化
+          watch([
+            () => accountsFilter.status, 
+            () => accountsFilter.search,
+            () => accountsFilter.registerTimeStart,
+            () => accountsFilter.registerTimeEnd,
+            () => accountsFilter.idMin,
+            () => accountsFilter.idMax,
+            () => accountsFilter.hasActivationLink,
+            () => accountsFilter.used
+          ], () => {
+            pagination.current = 1;
+            loadAccounts();
+          });
+          
+          watch([
+            () => logsFilter.username, 
+            () => logsFilter.operation, 
+            () => logsFilter.status
+          ], () => {
+            logsPagination.current = 1;
+            loadLogs();
+          });
+        });
+        
+        // 登录逻辑
+        const handleLogin = async () => {
+          if (!loginForm.password) {
+            ElementPlus.ElMessage.warning('请输入密码');
+            return;
+          }
+          loading.login = true;
+          try {
+            const res = await axios.post(`${API_BASE_URL}/login`, { password: loginForm.password });
+            setToken(res.data.token);
+            dialogs.login = false;
+            ElementPlus.ElMessage.success('登录成功');
+            // 登录后自动加载数据
+            loadAccounts();
+            loadStatistics();
+            loadTasks();
+          } catch (e) {
+            ElementPlus.ElMessage.error(e.response?.data?.detail || '登录失败');
+          } finally {
+            loading.login = false;
+          }
+        };
+
+        // 退出登录
+        const logout = () => {
+          clearToken();
+          dialogs.login = true;
+        };
+
+        // 检查token
+        const checkLogin = async () => {
+          const token = getToken();
+          if (!token) {
+            dialogs.login = true;
+            return false;
+          }
+          // 简单校验token有效性（可选：请求一个接口）
+          try {
+            await axios.get(`${API_BASE_URL}/statistics`);
+            return true;
+          } catch {
+            dialogs.login = true;
+            return false;
+          }
+        };
+
+        // 轮询任务状态的功能
+        const startTaskPolling = (taskId) => {
+          console.log(`开始轮询任务 ${taskId} 的状态`);
+          
+          if (runningTaskPolls[taskId]) {
+            // 如果已经在轮询这个任务，则不重复创建
+            return;
+          }
+          
+          // 创建一个轮询间隔，每10秒查询一次任务状态
+          const intervalId = setInterval(async () => {
+            try {
+              const response = await axios.get(`${API_BASE_URL}/tasks/${taskId}`);
+              const taskData = response.data;
+              
+              // 更新本地任务数据
+              tasks.value = { ...tasks.value, [taskId]: taskData };
+              
+              // 如果任务已完成或失败，停止轮询
+              if (taskData.status === 'completed' || taskData.status === 'failed') {
+                console.log(`任务 ${taskId} 已${taskData.status === 'completed' ? '完成' : '失败'}，停止轮询`);
+                clearInterval(runningTaskPolls[taskId]);
+                delete runningTaskPolls[taskId];
+                
+                // 提醒用户任务已完成
+                ElementPlus.ElMessage({
+                  message: `任务 ${taskId} 已${taskData.status === 'completed' ? '完成' : '失败'}，成功: ${taskData.success_count || 0}，失败: ${taskData.error_count || 0}`,
+                  type: taskData.status === 'completed' ? 'success' : 'warning',
+                  duration: 5000
+                });
+                
+                // 如果任务成功，刷新账号列表和统计信息
+                if (taskData.status === 'completed') {
+                  loadAccounts();
+                  loadStatistics();
+                }
+              }
+            } catch (error) {
+              console.error(`轮询任务 ${taskId} 状态失败:`, error);
+              // 如果出错，也停止轮询
+              clearInterval(runningTaskPolls[taskId]);
+              delete runningTaskPolls[taskId];
+            }
+          }, 10000); // 每10秒轮询一次
+          
+          // 保存轮询间隔ID，以便稍后可以停止它
+          runningTaskPolls[taskId] = intervalId;
+        };
+        
+        // 加载账号列表
+        const loadAccounts = async () => {
+          loading.accounts = true;
+          try {
+            const params = {
+              page: pagination.current,
+              per_page: pagination.pageSize
+            };
+            
+            if (accountsFilter.status !== null && accountsFilter.status !== '') params.status = accountsFilter.status;
+            if (accountsFilter.search) params.search = accountsFilter.search;
+            if (accountsFilter.registerTimeStart) params.register_time_start = accountsFilter.registerTimeStart;
+            if (accountsFilter.registerTimeEnd) params.register_time_end = accountsFilter.registerTimeEnd;
+            if (accountsFilter.idMin) params.id_min = accountsFilter.idMin;
+            if (accountsFilter.idMax) params.id_max = accountsFilter.idMax;
+            if (accountsFilter.hasActivationLink) params.has_activation_link = accountsFilter.hasActivationLink;
+            if (accountsFilter.used !== '' && accountsFilter.used !== null && accountsFilter.used !== undefined) params.used = accountsFilter.used;
+            
+            console.log('请求参数:', params);
+            const response = await axios.get(`${API_BASE_URL}/accounts`, { params });
+            console.log('API响应:', response.data);
+            
+            if (response.data && Array.isArray(response.data.accounts)) {
+              accounts.value = response.data.accounts;
+              pagination.total = response.data.total;
+              
+              // 调试信息 - 检查每个账号数据
+              accounts.value.forEach((account, index) => {
+                console.log(`账号[${index}]:`, account);
+                if (!account.id) console.warn(`账号[${index}] 缺少ID字段`);
+                if (!account.register_time) console.warn(`账号[${index}] 缺少注册时间字段`);
+                if (!account.username) console.warn(`账号[${index}] 缺少用户名字段`);
+              });
+              
+              // 如果应该有数据但显示不出来，尝试强制更新视图
+              if (accounts.value.length > 0) {
+                nextTick(() => {
+                  console.log('视图已更新');
+                });
+              }
+            } else {
+              console.error('API返回的数据格式不正确:', response.data);
+              ElementPlus.ElMessage.warning('API返回的数据格式不正确');
+            }
+          } catch (error) {
+            console.error('加载账号失败:', error);
+            ElementPlus.ElMessage.error('加载账号失败: ' + (error.response?.data?.detail || error.message));
+          } finally {
+            loading.accounts = false;
+          }
+        };
+        
+        // 加载统计信息
+        const loadStatistics = async () => {
+          loading.statistics = true;
+          try {
+            const response = await axios.get(`${API_BASE_URL}/statistics`);
+            Object.assign(statistics, response.data);
+          } catch (error) {
+            console.error('加载统计信息失败:', error);
+            ElementPlus.ElMessage.error('加载统计信息失败: ' + (error.response?.data?.detail || error.message));
+          } finally {
+            loading.statistics = false;
+          }
+        };
+        
+        // 加载任务列表
+        const loadTasks = async () => {
+          loading.tasks = true;
+          try {
+            const response = await axios.get(`${API_BASE_URL}/tasks`);
+            tasks.value = response.data;
+            
+            // 检查并为所有正在运行的任务启动轮询
+            Object.entries(response.data).forEach(([taskId, taskData]) => {
+              if (taskData.status === 'running' && !runningTaskPolls[taskId]) {
+                startTaskPolling(taskId);
+              }
+            });
+          } catch (error) {
+            console.error('加载任务列表失败:', error);
+            ElementPlus.ElMessage.error('加载任务列表失败: ' + (error.response?.data?.detail || error.message));
+          } finally {
+            loading.tasks = false;
+          }
+        };
+        
+        // 加载日志列表
+        const loadLogs = async () => {
+          loading.logs = true;
+          try {
+            const params = {
+              page: logsPagination.current,
+              per_page: logsPagination.pageSize
+            };
+            
+            if (logsFilter.username) {
+              params.username = logsFilter.username;
+            }
+            
+            if (logsFilter.operation) {
+              params.operation = logsFilter.operation;
+            }
+            
+            if (logsFilter.status) {
+              params.status = logsFilter.status;
+            }
+            
+            const response = await axios.get(`${API_BASE_URL}/logs`, { params });
+            logs.value = response.data.logs;
+            logsPagination.total = response.data.total;
+          } catch (error) {
+            console.error('加载日志失败:', error);
+            ElementPlus.ElMessage.error('加载日志失败: ' + (error.response?.data?.detail || error.message));
+          } finally {
+            loading.logs = false;
+          }
+        };
+        
+        // 分页事件处理
+        const handleSizeChange = (size) => {
+          pagination.pageSize = size;
+          loadAccounts();
+        };
+        
+        const handleCurrentChange = (page) => {
+          pagination.current = page;
+          loadAccounts();
+        };
+        
+        const handleLogsSizeChange = (size) => {
+          logsPagination.pageSize = size;
+          loadLogs();
+        };
+        
+        const handleLogsCurrentChange = (page) => {
+          logsPagination.current = page;
+          loadLogs();
+        };
+        
+        // 表格选择事件
+        const handleSelectionChange = (selection) => {
+          selectedAccounts.value = selection;
+        };
+        
+        // 标签页点击事件
+        const handleTabClick = (tab) => {
+          if (tab.props.name === 'logs') {
+            loadLogs();
+          }
+        };
+        
+        // 导入账号
+        const showImportDialog = () => {
+          dialogs.import = true;
+        };
+        
+        const handleImportFileChange = (event) => {
+          const file = event.target.files[0];
+          if (file) {
+            importForm.filepath = file;
+          }
+        };
+        
+        const importAccounts = async () => {
+          if (!importForm.filepath) {
+            ElementPlus.ElMessage.warning('请选择文件');
+            return;
+          }
+          
+          loading.import = true;
+          try {
+            const formData = new FormData();
+            formData.append('file', importForm.filepath);
+            
+            const response = await axios.post(`${API_BASE_URL}/import`, formData, {
+              headers: {
+                'Content-Type': 'multipart/form-data'
+              }
+            });
+            
+            ElementPlus.ElMessage.success(`成功导入 ${response.data.imported_count} 个账号`);
+            dialogs.import = false;
+            
+            // 重新加载数据
+            loadAccounts();
+            loadStatistics();
+          } catch (error) {
+            console.error('导入账号失败:', error);
+            ElementPlus.ElMessage.error('导入账号失败: ' + (error.response?.data?.detail || error.message));
+          } finally {
+            loading.import = false;
+          }
+        };
+        
+        // 导出账号
+        const showExportDialog = () => {
+          dialogs.export = true;
+        };
+        
+        const exportAccounts = async () => {
+          if (!exportForm.filename) {
+            ElementPlus.ElMessage.warning('请输入文件名');
+            return;
+          }
+          loading.export = true;
+          try {
+            // 导出时使用当前筛选条件
+            const params = {
+              filename: exportForm.filename
+            };
+            if (accountsFilter.status !== null && accountsFilter.status !== '') params.status = accountsFilter.status;
+            if (accountsFilter.used !== '' && accountsFilter.used !== null && accountsFilter.used !== undefined) params.used = accountsFilter.used;
+            if (accountsFilter.hasActivationLink) params.has_activation_link = accountsFilter.hasActivationLink;
+            if (accountsFilter.search) params.search = accountsFilter.search;
+            if (accountsFilter.registerTimeStart) params.register_time_start = accountsFilter.registerTimeStart;
+            if (accountsFilter.registerTimeEnd) params.register_time_end = accountsFilter.registerTimeEnd;
+            if (accountsFilter.idMin) params.id_min = accountsFilter.idMin;
+            if (accountsFilter.idMax) params.id_max = accountsFilter.idMax;
+
+            // 使用axios以blob方式请求导出数据
+            const response = await axios.post(`${API_BASE_URL}/export`, params, {
+              responseType: 'blob' // 设置响应类型为blob
+            });
+            
+            // 创建Blob链接并触发下载
+            const blob = new Blob([response.data], { type: 'text/plain' });
+            const url = window.URL.createObjectURL(blob);
+            const link = document.createElement('a');
+            link.href = url;
+            link.setAttribute('download', exportForm.filename); // 使用用户指定的文件名
+            document.body.appendChild(link);
+            link.click();
+            
+            // 清理资源
+            document.body.removeChild(link);
+            window.URL.revokeObjectURL(url);
+            
+            ElementPlus.ElMessage.success('文件已导出并下载到本地');
+            dialogs.export = false;
+          } catch (error) {
+            console.error('导出账号失败:', error);
+            ElementPlus.ElMessage.error('导出账号失败: ' + (error.response?.data?.detail || error.message));
+          } finally {
+            loading.export = false;
+          }
+        };
+        
+        // 重置失败账号
+        const resetFailedAccounts = async () => {
+          try {
+            const response = await axios.post(`${API_BASE_URL}/reset-failed`);
+            ElementPlus.ElMessage.success(response.data.message);
+            
+            // 重新加载数据
+            loadAccounts();
+            loadStatistics();
+          } catch (error) {
+            console.error('重置失败账号出错:', error);
+            ElementPlus.ElMessage.error('重置失败账号出错: ' + (error.response?.data?.detail || error.message));
+          }
+        };
+        
+        // 查看账号详情
+        const viewAccountDetails = (account) => {
+          currentAccount.value = {...account};
+          statusUpdateForm.status = account.status;
+          statusUpdateForm.activation_link = account.activation_link || '';
+          statusUpdateForm.notes = account.notes || '';
+          dialogs.accountDetails = true;
+        };
+        
+        // 更新账号状态
+        const updateAccountStatus = async () => {
+          if (currentAccount.value === null) {
+            return;
+          }
+          
+          loading.updateStatus = true;
+          try {
+            const response = await axios.post(
+              `${API_BASE_URL}/accounts/${currentAccount.value.id}/status`, 
+              statusUpdateForm
+            );
+            
+            ElementPlus.ElMessage.success('账号状态更新成功');
+            
+            // 更新本地数据
+            const index = accounts.value.findIndex(a => a.id === currentAccount.value.id);
+            if (index !== -1) {
+              accounts.value[index] = response.data;
+            }
+            
+            dialogs.accountDetails = false;
+            
+            // 重新加载统计数据
+            loadStatistics();
+          } catch (error) {
+            console.error('更新账号状态失败:', error);
+            ElementPlus.ElMessage.error('更新账号状态失败: ' + (error.response?.data?.detail || error.message));
+          } finally {
+            loading.updateStatus = false;
+          }
+        };
+        
+        // 删除账号
+        const deleteAccount = (account) => {
+          ElementPlus.ElMessageBox.confirm(
+            `确定要删除账号【${account.username}】吗？`,
+            '删除确认',
+            {
+              confirmButtonText: '删除',
+              cancelButtonText: '取消',
+              type: 'warning',
+            }
+          ).then(async () => {
+            try {
+              await axios.delete(`${API_BASE_URL}/accounts/${account.id}`);
+              ElementPlus.ElMessage.success('账号已删除');
+              loadAccounts();
+              loadStatistics();
+            } catch (error) {
+              ElementPlus.ElMessage.error('删除失败: ' + (error.response?.data?.detail || error.message));
+            }
+          }).catch(() => {});
+        };
+        
+        // 提交邮箱相关
+        const submitSelectedAccounts = () => {
+          submitForm.account_ids = selectedAccounts.value.map(account => account.id);
+          dialogs.submit = true;
+        };
+        
+        const submitSingleAccount = (account) => {
+          submitForm.account_ids = [account.id];
+          dialogs.submit = true;
+        };
+        
+        const confirmSubmit = async () => {
+          loading.submit = true;
+          try {
+            const response = await axios.post(`${API_BASE_URL}/submit`, {
+              account_ids: submitForm.account_ids,
+              max_workers: submitForm.max_workers,
+              proxy: submitForm.proxy || null
+            });
+            
+            const taskId = response.data.task_id;
+            ElementPlus.ElMessage.success('提交任务已启动，任务ID: ' + taskId);
+            dialogs.submit = false;
+            
+            // 切换到任务标签页
+            activeTab.value = 'tasks';
+            
+            // 延迟刷新任务列表
+            setTimeout(() => {
+              loadTasks();
+              
+              // 开始轮询任务状态
+              startTaskPolling(taskId);
+            }, 1000);
+          } catch (error) {
+            console.error('提交邮箱失败:', error);
+            ElementPlus.ElMessage.error('提交邮箱失败: ' + (error.response?.data?.detail || error.message));
+          } finally {
+            loading.submit = false;
+          }
+        };
+        
+        // 提取链接相关
+        const extractSelectedAccounts = () => {
+          extractForm.account_ids = selectedAccounts.value
+            .filter(account => account.status === 1)
+            .map(account => account.id);
+            
+          if (extractForm.account_ids.length === 0) {
+            ElementPlus.ElMessage.warning('没有选择已提交的账号');
+            return;
+          }
+          
+          dialogs.extract = true;
+        };
+        
+        const extractSingleAccount = (account) => {
+          if (account.status !== 1) {
+            ElementPlus.ElMessage.warning('只能为已提交的账号提取链接');
+            return;
+          }
+          
+          extractForm.account_ids = [account.id];
+          dialogs.extract = true;
+        };
+        
+        const confirmExtract = async () => {
+          loading.extract = true;
+          try {
+            const response = await axios.post(`${API_BASE_URL}/extract`, {
+              account_ids: extractForm.account_ids,
+              max_workers: extractForm.max_workers
+            });
+            
+            const taskId = response.data.task_id;
+            ElementPlus.ElMessage.success('提取任务已启动，任务ID: ' + taskId);
+            dialogs.extract = false;
+            
+            // 切换到任务标签页
+            activeTab.value = 'tasks';
+            
+            // 延迟刷新任务列表
+            setTimeout(() => {
+              loadTasks();
+              
+              // 开始轮询任务状态
+              startTaskPolling(taskId);
+            }, 1000);
+          } catch (error) {
+            console.error('提取链接失败:', error);
+            ElementPlus.ElMessage.error('提取链接失败: ' + (error.response?.data?.detail || error.message));
+          } finally {
+            loading.extract = false;
+          }
+        };
+        
+        // 切换账号used状态
+        const toggleAccountUsed = async (account) => {
+          try {
+            const response = await axios.post(`${API_BASE_URL}/accounts/${account.id}/toggle-used`);
+            account.used = response.data.used;
+            ElementPlus.ElMessage.success('已切换使用状态');
+          } catch (error) {
+            ElementPlus.ElMessage.error('切换失败: ' + (error.response?.data?.detail || error.message));
+          }
+        };
+
+        // 批量切换账号used状态
+        const batchToggleUsed = async (usedValue) => {
+          if (selectedAccounts.value.length === 0) return;
+          const ids = selectedAccounts.value.map(acc => acc.id);
+          const confirmMsg = usedValue ? `确定将选中账号批量标记为“已使用”？` : `确定将选中账号批量标记为“未使用”？`;
+          ElementPlus.ElMessageBox.confirm(confirmMsg, '批量操作确认', {
+            confirmButtonText: '确定',
+            cancelButtonText: '取消',
+            type: 'warning',
+          }).then(async () => {
+            try {
+              await axios.post(`${API_BASE_URL}/accounts/batch-toggle-used`, { ids, used: usedValue });
+              ElementPlus.ElMessage.success('批量操作成功');
+              loadAccounts();
+            } catch (error) {
+              ElementPlus.ElMessage.error('批量操作失败: ' + (error.response?.data?.detail || error.message));
+            }
+          }).catch(() => {});
+        };
+
+        // 复制到剪贴板并自动标记为已使用
+        const copyToClipboard = (text, account) => {
+          navigator.clipboard.writeText(text).then(async () => {
+            ElementPlus.ElMessage({
+              message: '已复制到剪贴板',
+              type: 'success',
+              duration: 1500
+            });
+            // 自动标记为已使用
+            if (account && !account.used) {
+              try {
+                const response = await axios.post(`${API_BASE_URL}/accounts/${account.id}/toggle-used`);
+                account.used = response.data.used;
+              } catch (error) {
+                // 忽略错误
+              }
+            }
+          }).catch(err => {
+            console.error('复制失败:', err);
+            ElementPlus.ElMessage.error('复制失败');
+          });
+        };
+        
+        // 清理函数 - 组件卸载时调用
+        onUnmounted(() => {
+          // 清理所有正在运行的轮询
+          Object.values(runningTaskPolls).forEach(intervalId => {
+            clearInterval(intervalId);
+          });
+        });
+        
+        // 工具函数 - 获取状态文本
+        const getStatusText = (status) => {
+          const statusMap = {
+            0: '未提交',
+            1: '已提交',
+            2: '提交失败',
+            3: '已提取链接'
+          };
+          return statusMap[status] || '未知状态';
+        };
+        
+        // 工具函数 - 获取状态类型（Element UI的tag类型）
+        const getStatusType = (status) => {
+          const typeMap = {
+            0: 'info',      // 未提交
+            1: 'primary',   // 已提交
+            2: 'danger',    // 提交失败
+            3: 'success'    // 已提取链接
+          };
+          return typeMap[status] || 'info';
+        };
+        
+        // 工具函数 - 获取任务状态文本
+        const getTaskStatusText = (status) => {
+          const statusMap = {
+            'running': '运行中',
+            'completed': '已完成',
+            'failed': '失败'
+          };
+          return statusMap[status] || status;
+        };
+        
+        // 工具函数 - 获取任务状态类型
+        const getTaskStatusType = (status) => {
+          const typeMap = {
+            'running': 'primary',
+            'completed': 'success',
+            'failed': 'danger'
+          };
+          return typeMap[status] || 'info';
+        };
+        
+        // 工具函数 - 获取任务状态图标
+        const getTaskStatusIcon = (status) => {
+          const iconMap = {
+            'running': 'Loading',
+            'completed': 'Check',
+            'failed': 'Close'
+          };
+          return iconMap[status] || '';
+        };
+        
+        // 工具函数 - 获取任务类型文本
+        const getTaskTypeText = (type) => {
+          const typeMap = {
+            'submit': '提交邮箱',
+            'extract': '提取链接'
+          };
+          return typeMap[type] || type;
+        };
+        
+        // 工具函数 - 获取操作文本
+        const getOperationText = (operation) => {
+          const operationMap = {
+            'submit_email': '提交邮箱',
+            'extract_link': '提取链接',
+            'submit_email_background': '后台提交',
+            'extract_link_background': '后台提取',
+            'update_status': '更新状态'
+          };
+          return operationMap[operation] || operation;
+        };
+        
+        // 工具函数 - 获取日志记录文本
+        const getMessageText = (message) => {  // 获取日志记录文本
+          //直接返回消息
+          return message || '-';
+        };
+        // 工具函数 - 获取日志状态类型
+        const getLogStatusType = (status) => {
+          const typeMap = {
+            'success': 'success',
+            'failed': 'danger',
+            'error': 'danger',
+            'processing': 'warning'
+          };
+          return typeMap[status] || 'info';
+        };
+        
+        // 工具函数 - 处理状态筛选变化
+        const handleStatusChange = (value) => {
+          console.log('状态筛选变化:', value);
+        };
+        
+        return {
+          activeTab,
+          accounts,
+          selectedAccounts,
+          currentAccount,
+          tasks,
+          logs,
+          statistics,
+          pagination,
+          logsPagination,
+          accountsFilter,
+          logsFilter,
+          importForm,
+          exportForm,
+          statusUpdateForm,
+          submitForm,
+          extractForm,
+          loginForm,
+          dialogs,
+          loading,
+          
+          // 方法
+          loadAccounts,
+          loadStatistics,
+          loadTasks,
+          loadLogs,
+          handleSizeChange,
+          handleCurrentChange,
+          handleLogsSizeChange,
+          handleLogsCurrentChange,
+          handleSelectionChange,
+          handleTabClick,
+          showImportDialog,
+          handleImportFileChange,
+          importAccounts,
+          showExportDialog,
+          exportAccounts,
+          resetFailedAccounts,
+          viewAccountDetails,
+          updateAccountStatus,
+          deleteAccount,
+          submitSelectedAccounts,
+          submitSingleAccount,
+          confirmSubmit,
+          extractSelectedAccounts,
+          extractSingleAccount,
+          confirmExtract,
+          toggleAccountUsed,
+          batchToggleUsed,
+          copyToClipboard,
+          handleLogin,
+          logout,
+          checkLogin,
+          
+          // 工具函数
+          getStatusText,
+          getStatusType,
+          getTaskStatusText,
+          getTaskStatusType,
+          getTaskStatusIcon,
+          getTaskTypeText,
+          getOperationText,
+          getLogStatusType,
+          getMessageText,
+          handleStatusChange
+        };
+      }
+    });
+    
+    // // 全局注册Element Plus
+    // for (const [key, component] of Object.entries(ElementPlus)) {
+    //   app.component(key, component);
+    // }
+
+    // 注册所有图标
+    for (const [key, component] of Object.entries(ElementPlusIconsVue)) {
+      app.component(key, component);
+    }
+    
+    // 使用Element Plus
+    app.use(ElementPlus);
+    
+    app.mount('#app');
+  </script>
+</body>
+</html>

jetbrains.py

@@ -0,0 +1,258 @@
+from typing import Optional, Dict, Any, Tuple
+import json
+import time
+import httpx
+from dataclasses import dataclass
+from DrissionPage import Chromium
+from DrissionPage._configs.chromium_options import ChromiumOptions
+from DrissionPage._pages.mix_tab import MixTab
+import os
+
+@dataclass
+class CaptchaConfig:
+    """验证码解决配置"""
+    speech2text_api: str = os.environ.get("SPEECH2TEXT_API", "")
+    auth_key: str = os.environ.get("AUTH_KEY", "")
+    # auth_key: str = "your_auth_key_here"  # 替换为你的API密钥
+    max_retries: int = 3
+    retry_delay: float = 1.0
+    page_load_timeout: float = 20.0
+    element_timeout: float = 5.0
+
+
+class CaptchaSolver:
+    def __init__(self, email: str, firstname, lastname, is_teacher: bool = False, config: Optional[CaptchaConfig] = None, proxy = None):
+        self.email = email
+        self.firstname = firstname
+        self.lastname = lastname
+        self.is_teacher = is_teacher
+        self.config = config or CaptchaConfig()
+        self.tab: Optional[MixTab] = None
+        self.proxy = proxy
+
+    def __enter__(self):
+        self.tab = self._init_browser()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # return False  # 允许异常传播
+        if self.tab:
+            self.tab.clear_cache()
+            self.tab.close()
+            self.tab.browser.quit()
+
+    def _init_browser(self) -> MixTab:
+        """初始化浏览器并返回标签页"""
+        co = ChromiumOptions().set_paths(browser_path=r".\Chrome\chrome.exe")
+        co.incognito(on_off=True)  # 无痕隐身模式打开的话。不会记住你的网站账号密码
+        # co.set_local_port("1236")
+        co.auto_port(on_off=True)
+
+        # co.headless(False)
+        co.headless(True)
+        co.set_user_agent(
+            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTM, like Gecko) chrome/124.0.0.8 safari/537.36')
+        # 阻止“自动保存密码”的提示气泡
+        co.set_pref('credentials_enable_service', False)
+        # 阻止“要恢复页面吗？Chrome未正确关闭”的提示气泡
+        co.set_argument('--hide-crash-restore-bubble')
+        co.set_proxy(proxy=self.proxy)
+        browser = Chromium(co)
+        browser.clear_cache()
+        tab = browser.new_tab()
+        tab.set.timeouts(page_load=self.config.page_load_timeout)
+        return tab
+    def _colese_browser(self):
+        """关闭浏览器并清理资源"""
+        if self.tab:
+            self.tab.clear_cache()
+            self.tab.close()
+            self.tab.browser.quit()
+    def _wait_for_element(self, selector: str, timeout: Optional[float] = None) -> Any:
+        """等待元素出现"""
+        timeout = timeout or self.config.element_timeout
+        return self.tab.ele(selector, timeout=timeout)
+
+    def get_audio_data(self) -> Tuple[Optional[str], bool]:
+        """
+        获取音频验证码数据
+        返回: (audio_data, needs_captcha)
+        """
+        try:
+            self.tab.get('https://www.jetbrains.com/shop/eform/students')
+
+            # 检查是否需要验证码
+            if "Human Verification" not in self.tab.title:
+                print("页面不需要人机验证")
+                return None, False
+
+            try:
+                # time.sleep(2)  # 等待页面加载
+                self.tab.wait.eles_loaded('#amzn-captcha-verify-button')
+                verify_btn = self._wait_for_element('#amzn-captcha-verify-button')
+                verify_btn.click(by_js=True)
+            except Exception:
+                # 如果找不到验证按钮，可能已经通过验证
+                if self._wait_for_element('@name=email', timeout=2):
+                    print("已经不需要人机验证")
+                    return None, False
+                raise
+
+            # 设置监听并点击音频按钮
+            self.tab.listen.start('problem?kind=audio')
+            audio_btn = self._wait_for_element('#amzn-btn-audio-internal')
+            audio_btn.click(by_js=True)
+
+            # 等待并获取音频数据
+            for _ in range(self.config.max_retries):
+                res = self.tab.listen.wait()
+                try:
+                    audio_data = res.response.body
+                    return audio_data['assets']['audio'], True
+                except (json.JSONDecodeError, KeyError):
+                    print("数据包解析失败，继续等待...")
+                    time.sleep(self.config.retry_delay)
+
+            raise TimeoutError("获取音频数据超时")
+
+        except Exception as e:
+            print(f"获取音频数据失败: {str(e)}")
+            return None, False
+
+    def call_whisper_api(self, audio_base64: str) -> Optional[Dict[str, Any]]:
+        """调用Whisper API进行语音识别"""
+        print("开始识别人机验��码")
+        
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.8 Safari/537.36"
+        }
+        if self.config.auth_key:
+            headers["Authorization"] = f"Bearer {self.config.auth_key}"
+        payload = {
+            "audio": audio_base64,
+            "task": "translate"
+        }
+
+        try:
+            with httpx.Client(timeout=20) as client:
+                response = client.post(
+                    self.config.speech2text_api,
+                    headers=headers,
+                    json=payload
+                )
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPError as e:
+            print(f"API请求失败: {str(e)}")
+            return None
+        except json.JSONDecodeError:
+            print("API响应解析失败")
+            return None
+
+    @staticmethod
+    def parse_result(result: Dict[str, Any]) -> str:
+        """解析语音识别结果"""
+        # if not result or 'segments' not in result or not result['segments']:
+        #     raise ValueError("无效的API响应: 缺少segments字段")
+
+        # last_segment = result['segments'][-1].get('text', '').strip()
+        if 'text' not in result:
+            raise ValueError("无效的API响应: 缺少text字段")
+        last_segment = result.get('text', '').strip()
+        if not last_segment:
+            raise ValueError("无法从结果中提取文本")
+
+        # 清理结果: 取最后一个词，移除空格和标点
+        last_word = last_segment.split()[-1]
+        return last_word.replace(' ', '').replace('.', '').replace(',', '')
+
+    def fill_form(self) -> bool:
+        """填写并提交表单"""
+        try:
+            # 等待表单元素出现
+            self.tab.wait.eles_loaded('@name=email')
+            email_input = self._wait_for_element('@name=email')
+            email_input.input(self.email, clear=True)
+
+            role_value = "TEACHER" if self.is_teacher else "STUDENT"
+            self._wait_for_element(f'@@name=studentType@@value={role_value}').click(by_js=True)
+            self._wait_for_element('@name=name.firstName').input(self.firstname, clear=True)
+            self._wait_for_element('@name=name.lastName').input(self.lastname, clear=True)
+            self._wait_for_element('@name=privacyPolicy').click(by_js=True)
+
+            submit_btn = self._wait_for_element('xpath://button[@type="submit"]')
+            submit_btn.click(by_js=True)
+
+            return True
+        except Exception as e:
+            print(f"表单填写失败: {str(e)}")
+            return False
+    def check_success(self) -> bool:
+        """检查表单提交是否成功"""
+        try:
+            if "primaryConfirmation?email=" in self.tab.url:
+                print(f"{self.email} 提交成功")
+                return True
+            else:
+                print(f"{self.email} 提交失败")
+                return False
+        except Exception as e:
+            print(f"检查提交状态失败:{self.email} {str(e)}")
+            return False
+
+    def solve_audio_captcha(self) -> bool | None:
+        """主流程: 解决音频验证码并提交表单"""
+        try:
+            while True:
+                # 1. 获取音频数据
+                print(f"{self.email} 正在获取音频验证码")
+                audio_data, needs_captcha = self.get_audio_data()
+
+                if needs_captcha and audio_data:
+                    # 2. 调用API识别
+                    result = self.call_whisper_api(audio_data)
+                    if not result:
+                        raise RuntimeError("语音识别API调用失败")
+                    print(result)
+                    # 3. 解析结果
+                    last_word = self.parse_result(result)
+                    print(f"识别结果: {last_word}")
+
+                    # 4. 提交验证码
+                    input_field = self._wait_for_element('tag:input')
+                    input_field.input(last_word)
+                    time.sleep(1)  # 短暂等待确保输入完成
+
+                    verify_btn = self._wait_for_element('#amzn-btn-verify-internal')
+                    verify_btn.click(by_js=True)
+                    time.sleep(2)  # 等待验证结果
+                    if "Human Verification" in self.tab.title:
+                        print("验证码验证失败，重试")
+                        continue
+                # 5. 填写表单
+                if not self.fill_form():
+                    raise RuntimeError("表单填写失败")
+                # 6. 检查提交状态
+                time.sleep(1)  # 等待页面加载
+                if not self.check_success():
+                    raise RuntimeError("表单提交失败")
+                print("验证流程完成")
+                return True
+
+        except Exception as e:
+            print(f"处理过程中发生错误: {str(e)}")
+            return False
+
+
+if __name__ == "__main__":
+    # 示例用法
+    with CaptchaSolver(email="[email protected]",
+                       firstname="John",
+                       lastname="Doe",
+                       is_teacher=True,
+                       ) as solver:
+        success = solver.solve_audio_captcha()
+        if not success:
+            exit(1)

unibo_auth2_get_AuthCode_RefreshToken_sucsses.py

@@ -0,0 +1,391 @@
+import concurrent.futures
+import json
+import os
+import re
+import threading
+from datetime import datetime
+
+import httpx
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin, urlencode
+from loguru import logger
+
+# logger.stop()
+# 定义线程安全计数器和锁
+success_counter = 0
+error_counter = 0
+# 定义文件名 filename = user-当前月份-日期.txt
+current_date = datetime.now().strftime("%m-%d")
+# filename = f'user-{current_date}.txt'
+counter_lock = threading.Lock()
+success_file_lock = threading.Lock()
+error_file_lock = threading.Lock()
+
+
+class OAuth2Authenticator:
+    def __init__(self, username, password):
+        self.username = username
+        self.password = password
+        self.client_id = '9e5f94bc-e8a4-4e73-b8be-63364c29d753'
+        self.session = httpx.Client(timeout=30.0, follow_redirects=True, verify=False)
+        self.base_urls = {
+            'microsoft': 'https://login.microsoftonline.com',
+            'idp': 'https://idp.unibo.it'
+        }
+        self.current_state = {}  # 用于存储流程中的临时数据
+
+    def _extract_input_value(self, html, name):
+        """从HTML中提取指定名称的input值"""
+        soup = BeautifulSoup(html, 'html.parser')
+        element = soup.find('input', {'name': name})
+        return element['value'] if element else None
+
+    def _make_request(self, method, url, data=None, **kwargs):
+        """封装请求方法，统一处理异常"""
+        try:
+            # 设置默认的请求头
+            self.session.headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Thunderbird/137.0',
+                # 'Accept': 'application/json, text/javascript, */*; q=0.01',
+                # 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+                # 'X-Requested-With': 'XMLHttpRequest'
+            }
+
+            response = self.session.request(method, url, data=data, **kwargs)
+            url = response.url
+            print(f"请求的URL: {url}")
+            # response.raise_for_status()
+            return response
+        except httpx.ConnectError as e:
+            # print(f"连接失败的目标URL: {e.request.url}")
+            # print(f"错误详情: {e}")
+            raise ValueError(e.request.url)
+        except Exception as e:
+            print(f"其他错误: {e}")
+            raise
+
+    def _build_auth_url(self):
+        """构建初始认证URL"""
+        params = {
+            'response_type': 'code',
+            'client_id': self.client_id,
+            'redirect_uri': 'https://localhost',
+            'scope': 'https://outlook.office.com/EWS.AccessAsUser.All https://outlook.office.com/IMAP.AccessAsUser.All https://outlook.office.com/POP.AccessAsUser.All https://outlook.office.com/SMTP.Send offline_access',
+            'login_hint': self.username
+        }
+        return f"{self.base_urls['microsoft']}/common/oauth2/v2.0/authorize?{urlencode(params)}"
+
+    def step1_get_initial_login_page(self):
+        """第一步: 获取初始登录页面并提取SAML参数"""
+        logger.info("执行第一步: 获取初始登录页面")
+        auth_url = self._build_auth_url()
+        response = self._make_request('GET', auth_url)
+
+        # self.current_state['relay_state'] = self._extract_input_value(response.text, 'RelayState')
+        # self.current_state['saml_request'] = self._extract_input_value(response.text, 'SAMLRequest')
+
+        # if not all([self.current_state['relay_state'], self.current_state['saml_request']]):
+        #     raise ValueError("无法从登录页面提取必要的SAML参数")
+        config_match = re.search(r'\$Config=({.*?//])', response.text, re.DOTALL)
+        if config_match:
+            config_value = config_match.group(1).replace('//]', '').strip()
+            self.current_state['config'] = json.loads(config_value[:-1])
+        else:
+            raise ValueError("无法从响应中提取配置信息")
+        return response
+
+    def step2_submit_saml_request(self):
+        """第二步: 提交SAML请求到IDP"""
+        logger.info("执行第二步: 提交SAML请求到IDP")
+
+        data = {
+            "UserName": self.username,
+            "Password": self.password,
+            "AuthMethod": "FormsAuthentication"
+        }
+        idp_sso_url = self.current_state['config'].get('bsso').get('failureRedirectUrl')
+        logger.info(f"IDP SSO URL: {idp_sso_url}")
+        response = self._make_request('POST', idp_sso_url, data=data)
+        # 提取配置信息
+        logger.info(f"LAST URL: {response.url}")
+
+        self.current_state['wa'] = self._extract_input_value(response.text, 'wa')
+        self.current_state['wresult'] = self._extract_input_value(response.text, 'wresult')
+        self.current_state['wctx'] = self._extract_input_value(response.text, 'wctx')
+        # if not self.current_state['csrf_token']:
+        #     raise ValueError("无法从响应中提取CSRF令牌")
+
+        return response
+
+    def step3_submit_loginsrf_response(self):
+        """第三步: 提交登录响应"""
+        logger.info("执行第三步: 提交登录响应")
+
+        response = self._make_request('POST',
+                                      urljoin(self.base_urls['microsoft'], '/login.srf'),
+                                      data={
+                                          "wa": self.current_state['wa'],
+                                          "wresult": self.current_state['wresult'],
+                                          "wctx": self.current_state['wctx']
+                                      }
+                                      )
+        config_match = re.search(r'\$Config=({.*?//])', response.text, re.DOTALL)
+        if config_match:
+            config_value = config_match.group(1).replace('//]', '').strip()
+            self.current_state['config'] = json.loads(config_value[:-1])
+        else:
+            raise ValueError("无法从响应中提取配置信息")
+        return response
+
+    def step6_submit_saml_response(self):
+        """第六步: 处理授权同意"""
+        logger.info("执行第六步: 处理授权同意")
+        if 'config' not in self.current_state:
+            raise ValueError("缺少配置信息")
+
+        config = self.current_state['config']
+        response = self._make_request('POST',
+                                      urljoin(self.base_urls['microsoft'], '/appverify'),
+                                      data={
+                                          "ContinueAuth": True,
+                                          "ctx": config.get("sCtx"),
+                                          "hpgrequestid": config.get("sessionId"),
+                                          "flowToken": config.get("sFT"),
+                                          "iscsrfspeedbump": True,
+                                          "canary": config.get("canary"),
+                                          "i19": 492026
+                                      }
+                                      )
+
+        # 提取配置信息
+        config_match = re.search(r'\$Config=({.*?//])', response.text, re.DOTALL)
+        if config_match:
+            config_value = config_match.group(1).replace('//]', '').strip()
+            self.current_state['config'] = json.loads(config_value[:-1])
+        else:
+            raise ValueError("无法从响应中提取配置信息")
+
+        return response
+
+    def step7_handle_consent(self):
+        """第七步: 处理授权同意"""
+        logger.info("执行第七步: 处理授权同意")
+        if 'config' not in self.current_state:
+            raise ValueError("缺少配置信息")
+
+        config = self.current_state['config']
+        response = self._make_request('POST',
+                                      urljoin(self.base_urls['microsoft'], '/common/Consent/Set'),
+                                      data={
+                                          "acceptConsent": True,
+                                          "ctx": config.get("sCtx"),
+                                          "hpgrequestid": config.get("sessionId"),
+                                          "flowToken": config.get("sFT"),
+                                          "canary": config.get("canary"),
+                                          "i19": 958761
+                                      }
+                                      )
+
+        if 'localhost/?code=' in response.url:
+            self.current_state['auth_code'] = self._extract_auth_code(response.url)
+            return response
+
+        raise ValueError("未能成功获取授权码")
+
+    def _extract_auth_code(self, url):
+        """从URL中提取授权码"""
+        logger.info(f'提取授权码: {url}')
+        url = str(url)
+        match = re.search(r'code=([^&]+)', url)
+        return match.group(1) if match else None
+
+    def get_refresh_token(self, code):
+        """获取刷新令牌"""
+        url = "https://login.microsoftonline.com/common/oauth2/v2.0/token"
+        data = {
+            'client_id': self.client_id,
+            'grant_type': 'authorization_code',
+            'redirect_uri': 'https://localhost',
+            'code': code
+        }
+        response = self._make_request('POST', url, data=data)
+        response_data = response.json()
+        if 'error' in response_data:
+            raise ValueError(f"获取刷新令牌失败: {response_data['error_description']}")
+        refresh_token = response_data.get('refresh_token')
+        access_token = response_data.get('access_token')
+        return refresh_token, access_token
+
+    def execute_flow(self):
+        """执行完整的OAuth2认证流程"""
+        try:
+            # 更新每一步的last_url
+            response = self.step1_get_initial_login_page()
+            self.current_state['last_url'] = response.url
+            response = self.step2_submit_saml_request()
+            self.current_state['last_url'] = response.url
+            response = self.step3_submit_loginsrf_response()
+            self.current_state['last_url'] = response.url
+            response = self.step6_submit_saml_response()
+            self.current_state['last_url'] = response.url
+
+            response = self.step7_handle_consent()
+            self.current_state['last_url'] = response.url
+
+            if 'auth_code' in self.current_state:
+                return self.current_state['auth_code']
+
+            raise Exception("认证流程未完成")
+
+        except Exception as e:
+            code = self._extract_auth_code(e)
+            if code:
+                # logger.info(f"提取到的授权码: {code}")
+                return code
+            else:
+                logger.info(f"认证流程出错: {e}")
+                logger.info("未能提取到授权码")
+            raise
+
+
+def handle_success(username, original_line_new):
+    """处理成功账号，线程安全地写入文件并更新计数器"""
+    global success_counter
+    try:
+        with success_file_lock:
+            with open(success_file, 'a', encoding='utf-8') as file:
+                file.write(original_line_new + '\n')
+
+        with counter_lock:
+            success_counter += 1
+            current_count = success_counter
+
+        logger.info(f"{username} 已写入成功文件，当前成功数: {success_counter},当前失败数: {error_counter}")
+    except Exception as e:
+        logger.error(f"写入成功账号 {username} 时出错: {str(e)}")
+
+
+def handle_failure(username, original_line):
+    """处理失败账号，线程安全地写入文件并更新计数器"""
+    global error_counter
+
+    try:
+        with error_file_lock:
+            with open(error_file, 'a', encoding='utf-8') as file:
+                file.write(original_line + '\n')
+
+        with counter_lock:
+            error_counter += 1
+            current_count = error_counter
+
+        logger.info(f"{username} 已写入失败文件，当前成功数: {success_counter},当前失败数: {error_counter}")
+    except Exception as e:
+        logger.error(f"写入失败账号 {username} 时出错: {str(e)}")
+
+
+def read_user_credentials(filepath='user.txt'):
+    """从user.txt文件中读取用户名和密码"""
+    credentials = []
+    try:
+        with open(filepath, 'r', encoding='utf-8') as file:
+            for line in file:
+                parts = line.strip().split('---')
+                if len(parts) >= 3:  # 至少需要时间、用户名和密码
+                    timestamp = parts[0]
+                    username = parts[1]
+                    password = parts[2]
+                    email = parts[3] if len(parts) > 3 else ""
+                    credentials.append((username, password, email, line.strip()))
+        logger.info(f"成功从{filepath}读取了{len(credentials)}个账号信息")
+        return credentials
+    except Exception as e:
+        logger.error(f"读取凭据文件时出错: {str(e)}")
+        return []
+
+
+def ensure_files_exist():
+    """确保输出文件存在"""
+
+    files = [success_file, error_file]
+    for file in files:
+        try:
+            if not os.path.exists(file):
+                with open(file, 'w', encoding='utf-8') as f:
+                    pass
+                logger.info(f"创建文件 {file}")
+        except Exception as e:
+            logger.error(f"创建文件 {file} 时出错: {str(e)}")
+            return False
+    return True
+def main_threaded(username, password, original_line):
+    authenticator = OAuth2Authenticator(
+        username=username,
+        password=password,  # 实际使用时应从安全来源获取密码
+    )
+
+    try:
+        auth_code = authenticator.execute_flow()
+        refresh_token, access_token = authenticator.get_refresh_token(auth_code)
+        print(f"成功获取授权码:\n{auth_code}\n{refresh_token}\n{access_token}\n")
+        # 报错
+        original_line_new = f'{original_line}---{refresh_token}'
+        handle_success(username, original_line_new)
+    except Exception as e:
+        print(f"认证失败: {e}")
+        handle_failure(username, original_line)
+
+# 使用示例
+if __name__ == "__main__":
+
+    # authenticator = OAuth2Authenticator(
+    #     username='[email protected]',
+    #     password='W17M&HQK^x1q7h.',  # 实际使用时应从安全来源获取密码
+    # )
+    #
+    # try:
+    #     auth_code = authenticator.execute_flow()
+    #     refresh_token, access_token = authenticator.get_refresh_token(auth_code)
+    #     print(f"成功获取授权码:\n{auth_code}\n{refresh_token}\n{access_token}\n")
+    # except Exception as e:
+    #     print(f"认证失败: {e}")
+    filename = 'user-4-21-success.txt'
+    success_file = filename.replace('success.txt', 'refresh-success.txt')
+    error_file = filename.replace('error.txt', 'refresh-error.txt')
+    filepath = filename
+    credentials = read_user_credentials(filepath)
+    if not credentials:
+        logger.error("没有读取到有效凭据，退出程序")
+        exit(1)
+
+    # 确保输出文件存在
+    if not ensure_files_exist():
+        logger.error("创建输出文件失败，退出程序")
+        exit(1)
+
+    # 设置最大线程数
+    max_workers = 1  # 可以根据需要调整线程数量
+
+    logger.info(f"开始多线程处理账号，最大并发数: {max_workers}")
+
+    # 使用线程池处理账号
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+        # 提交所有任务
+        futures = []
+        for username, password, email, original_line in credentials:
+            # 提交任务到线程池
+            future = executor.submit(
+                main_threaded,
+                username,
+                password,
+                original_line
+            )
+            futures.append(future)
+
+        # 等待所有任务完成
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                future.result()  # 获取结果，但我们不需要处理
+            except Exception as e:
+                logger.error(f"执行任务时发生异常: {str(e)}")
+
+    logger.info(f"处理完成，共成功 {success_counter} 个账号，失败 {error_counter} 个账号。")

unibo_jetbrains_activation.py

@@ -0,0 +1,725 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import re
+import time
+import random
+import sqlite3
+import threading
+import concurrent.futures
+from datetime import datetime
+from typing import Optional, Tuple, List, Dict, Any
+
+from loguru import logger
+from jetbrains import CaptchaSolver
+from 收发邮件 import EmailClient
+
+# 定义数据库状态常量
+STATUS_PENDING = 0        # 未提交
+STATUS_SUBMITTED = 1      # 已提交成功
+STATUS_FAILED = 2         # 提交失败
+STATUS_LINK_EXTRACTED = 3 # 已提取激活链接
+
+class DatabaseManager:
+    """数据库操作类，处理SQLite数据库的所有操作"""
+    
+    def __init__(self, db_path: str = "unibo_jetbrains.db"):
+        """初始化数据库连接和表结构
+        
+        Args:
+            db_path: 数据库文件路径
+        """
+        self.db_path = db_path
+        self.conn = None
+        self.lock = threading.Lock()  # 用于线程安全的数据库操作
+        self._initialize_db()
+    
+    def _initialize_db(self) -> None:
+        """初始化数据库，创建必要的表结构"""
+        self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        cursor = self.conn.cursor()
+        
+        # 创建邮箱数据表
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS accounts (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            register_time TEXT NOT NULL,
+            username TEXT NOT NULL UNIQUE,
+            password TEXT NOT NULL,
+            security_email TEXT,
+            status INTEGER DEFAULT 0,
+            activation_link TEXT,
+            updated_at TEXT,
+            notes TEXT,
+            used INTEGER DEFAULT 0 -- 新增字段，0未使用，1已使用
+        )
+        ''')
+        
+        # 创建日志表
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS operation_logs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT NOT NULL,
+            operation TEXT NOT NULL,
+            status TEXT NOT NULL,
+            message TEXT,
+            created_at TEXT NOT NULL
+        )
+        ''')
+        
+        self.conn.commit()
+        logger.info(f"数据库初始化完成: {self.db_path}")
+    
+    def __del__(self):
+        """析构函数，确保数据库连接正确关闭"""
+        if self.conn:
+            self.conn.close()
+    
+    def import_from_file(self, filepath: str) -> int:
+        """从文件导入账号数据
+        
+        Args:
+            filepath: 包含账号数据的文件路径
+            
+        Returns:
+            导入的账号数量
+        """
+        count = 0
+        try:
+            with self.lock, open(filepath, 'r', encoding='utf-8') as file:
+                cursor = self.conn.cursor()
+                
+                for line in file:
+                    parts = line.strip().split('---')
+                    if len(parts) >= 3:  # 至少需要时间、用户名和密码
+                        register_time = parts[0]
+                        username = parts[1]
+                        password = parts[2]
+                        security_email = parts[3] if len(parts) > 3 else ""
+                        status = 0  # 默认为未提交状态
+                        activation_link = ""
+                        
+                        # 检查更多部分以确定状态和激活链接
+                        if len(parts) > 4 and "success" in parts[4].lower():
+                            status = STATUS_SUBMITTED
+                        
+                        if len(parts) > 5 and "http" in parts[5].lower():
+                            activation_link = parts[5]
+                            status = STATUS_LINK_EXTRACTED
+                        
+                        # 插入或更新数据库
+                        try:
+                            cursor.execute('''
+                            INSERT OR IGNORE INTO accounts 
+                            (register_time, username, password, security_email, status, activation_link, updated_at) 
+                            VALUES (?, ?, ?, ?, ?, ?, datetime('now', 'localtime'))
+                            ''', (register_time, username, password, security_email, status, activation_link))
+                            
+                            if cursor.rowcount > 0:
+                                count += 1
+                        except sqlite3.IntegrityError:
+                            logger.warning(f"账号已存在，跳过: {username}")
+                
+                self.conn.commit()
+                logger.info(f"成功从{filepath}导入了{count}个账号")
+                return count
+        except Exception as e:
+            logger.error(f"从文件导入账号时出错: {str(e)}")
+            return 0
+    
+    def get_pending_accounts(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """获取待处理的账号（未提交状态）
+        
+        Args:
+            limit: 返回账号的最大数量
+            
+        Returns:
+            账号列表，每个账号是一个字典
+        """
+        with self.lock:
+            cursor = self.conn.cursor()
+            cursor.execute('''
+            SELECT id, register_time, username, password, security_email, status, activation_link 
+            FROM accounts 
+            WHERE status = ? 
+            LIMIT ?
+            ''', (STATUS_PENDING, limit))
+            
+            accounts = []
+            for row in cursor.fetchall():
+                accounts.append({
+                    'id': row[0],
+                    'register_time': row[1],
+                    'username': row[2],
+                    'password': row[3],
+                    'security_email': row[4],
+                    'status': row[5],
+                    'activation_link': row[6]
+                })
+            
+            return accounts
+    
+    def get_submitted_accounts(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """获取已提交但未提取链接的账号
+        
+        Args:
+            limit: 返回账号的最大数量
+            
+        Returns:
+            账号列表，每个账号是一个字典
+        """
+        with self.lock:
+            cursor = self.conn.cursor()
+            cursor.execute('''
+            SELECT id, register_time, username, password, security_email, status, activation_link 
+            FROM accounts 
+            WHERE status = ? AND (activation_link IS NULL OR activation_link = '')
+            LIMIT ?
+            ''', (STATUS_SUBMITTED, limit))
+            
+            accounts = []
+            for row in cursor.fetchall():
+                accounts.append({
+                    'id': row[0],
+                    'register_time': row[1],
+                    'username': row[2],
+                    'password': row[3],
+                    'security_email': row[4],
+                    'status': row[5],
+                    'activation_link': row[6]
+                })
+            
+            return accounts
+    
+    def update_account_status(self, id: int, status: int, activation_link: str = None, notes: str = None) -> bool:
+        """更新账号状态
+        
+        Args:
+            id: 账号ID
+            status: 新状态
+            activation_link: 激活链接（可选）
+            notes: 备注信息（可选）
+            
+        Returns:
+            更新成功返回True，否则返回False
+        """
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+                
+                if activation_link and notes:
+                    cursor.execute('''
+                    UPDATE accounts 
+                    SET status = ?, activation_link = ?, notes = ?, updated_at = datetime('now', 'localtime')
+                    WHERE id = ?
+                    ''', (status, activation_link, notes, id))
+                elif activation_link:
+                    cursor.execute('''
+                    UPDATE accounts 
+                    SET status = ?, activation_link = ?, updated_at = datetime('now', 'localtime')
+                    WHERE id = ?
+                    ''', (status, activation_link, id))
+                elif notes:
+                    cursor.execute('''
+                    UPDATE accounts 
+                    SET status = ?, notes = ?, updated_at = datetime('now', 'localtime')
+                    WHERE id = ?
+                    ''', (status, notes, id))
+                else:
+                    cursor.execute('''
+                    UPDATE accounts 
+                    SET status = ?, updated_at = datetime('now', 'localtime')
+                    WHERE id = ?
+                    ''', (status, id))
+                
+                self.conn.commit()
+                return cursor.rowcount > 0
+        except Exception as e:
+            logger.error(f"更新账号状态时出错: {str(e)}")
+            return False
+    
+    def log_operation(self, username: str, operation: str, status: str, message: str = None) -> None:
+        """记录操作日志
+        
+        Args:
+            username: 相关的用户名
+            operation: 操作类型
+            status: 操作状态
+            message: 附加信息
+        """
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                INSERT INTO operation_logs 
+                (username, operation, status, message, created_at) 
+                VALUES (?, ?, ?, ?, datetime('now', 'localtime'))
+                ''', (username, operation, status, message))
+                self.conn.commit()
+        except Exception as e:
+            logger.error(f"记录操作日志时出错: {str(e)}")
+    
+    def export_results_to_file(self, filepath: str, status: int = None) -> int:
+        """将结果导出到文件
+        
+        Args:
+            filepath: 输出文件路径
+            status: 筛选的状态（可选）
+            
+        Returns:
+            导出的记录数量
+        """
+        try:
+            with self.lock, open(filepath, 'w', encoding='utf-8') as file:
+                cursor = self.conn.cursor()
+                
+                if status is not None:
+                    cursor.execute('''
+                    SELECT register_time, username, password, security_email, status, activation_link 
+                    FROM accounts 
+                    WHERE status = ?
+                    ''', (status,))
+                else:
+                    cursor.execute('''
+                    SELECT register_time, username, password, security_email, status, activation_link 
+                    FROM accounts
+                    ''')
+                
+                count = 0
+                for row in cursor.fetchall():
+                    # 将状态码转换为文本
+                    status_text = ""
+                    if row[4] == STATUS_SUBMITTED:
+                        status_text = "success"
+                    elif row[4] == STATUS_FAILED:
+                        status_text = "failed"
+                    elif row[4] == STATUS_LINK_EXTRACTED:
+                        status_text = "successed"
+                    
+                    # 构建输出行
+                    if row[5]:  # 如果有激活链接
+                        line = f"{row[0]}---{row[1]}---{row[2]}---{row[3]}---{status_text}---{row[5]}\n"
+                    elif status_text:
+                        line = f"{row[0]}---{row[1]}---{row[2]}---{row[3]}---{status_text}\n"
+                    else:
+                        line = f"{row[0]}---{row[1]}---{row[2]}---{row[3]}\n"
+                    
+                    file.write(line)
+                    count += 1
+                
+                return count
+        except Exception as e:
+            logger.error(f"导出结果到文件时出错: {str(e)}")
+            return 0
+
+
+class JetbrainsSubmitter:
+    """提交邮箱到JetBrains获取激活链接的类"""
+    
+    def __init__(self, db_manager: DatabaseManager, proxy: str = None):
+        """初始化提交器
+        
+        Args:
+            db_manager: 数据库管理器实例
+            proxy: 代理服务器地址
+        """
+        self.db_manager = db_manager
+        self.proxy = proxy
+        logger.info("JetbrainsSubmitter 初始化完成")
+    
+    def random_name(self) -> Tuple[str, str]:
+        """生成随机的意大利名字和姓氏
+        
+        Returns:
+            (名字, 姓氏)元组
+        """
+        first_names = [
+            "Marco", "Giuseppe", "Antonio", "Giovanni", "Mario", "Luigi", "Paolo", "Francesco", "Roberto", "Stefano",
+            "Alessandro", "Andrea", "Giorgio", "Bruno", "Carlo", "Enrico", "Fabio", "Davide", "Claudio", "Massimo",
+            "Sofia", "Giulia", "Isabella", "Valentina", "Chiara", "Laura", "Maria", "Anna", "Francesca", "Elena",
+            "Alessandra", "Martina", "Giovanna", "Rosa", "Angela", "Lucia", "Paola", "Silvia", "Monica", "Cristina"
+        ]
+        last_names = [
+            "Rossi", "Ferrari", "Russo", "Bianchi", "Romano", "Gallo", "Costa", "Fontana", "Conti", "Esposito",
+            "Ricci", "Bruno", "De Luca", "Moretti", "Marino", "Greco", "Barbieri", "Lombardi", "Giordano", "Colombo",
+            "Mancini", "Longo", "Leone", "Martinelli", "Santoro", "Mariani", "Vitale", "Ferraro", "Rinaldi", "Villa"
+        ]
+        return random.choice(first_names), random.choice(last_names)
+    
+    def submit_email(self, account: Dict[str, Any]) -> bool:
+        """提交邮箱到JetBrains获取激活链接
+        
+        Args:
+            account: 账号信息字典
+            
+        Returns:
+            提交成功返回True，否则返回False
+        """
+        username = account['username']
+        logger.info(f"正在尝试提交邮箱: {username} 到JetBrains...")
+        
+        try:
+            firstname, lastname = self.random_name()
+            
+            # 使用CaptchaSolver提交邮箱
+            with CaptchaSolver(
+                email=username,
+                firstname=firstname,
+                lastname=lastname,
+                is_teacher=False,
+                proxy=self.proxy
+            ) as solver:
+                success = solver.solve_audio_captcha()
+            
+            if success:
+                logger.info(f"邮箱 {username} 提交成功")
+                self.db_manager.update_account_status(account['id'], STATUS_SUBMITTED)
+                self.db_manager.log_operation(username, "submit_email", "success")
+                return True
+            else:
+                logger.warning(f"邮箱 {username} 提交失败 (CaptchaSolver返回False)")
+                self.db_manager.update_account_status(account['id'], STATUS_FAILED, notes="提交失败请手动检查")
+                self.db_manager.log_operation(username, "submit_email", "failed", "CaptchaSolver返回False")
+                return False
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"提交邮箱 {username} 时发生错误: {error_msg}")
+            self.db_manager.update_account_status(account['id'], STATUS_FAILED, notes=f"认证失败: {error_msg[:100]}")
+            self.db_manager.log_operation(username, "submit_email", "error", error_msg[:200])
+            return False
+    
+    def submit_batch(self, max_accounts: int = 5, max_workers: int = 3) -> Tuple[int, int]:
+        """批量提交邮箱
+        
+        Args:
+            max_accounts: 最大处理账号数量
+            max_workers: 最大并发线程数
+            
+        Returns:
+            (成功数量, 失败数量)元组
+        """
+        accounts = self.db_manager.get_pending_accounts(limit=max_accounts)
+        if not accounts:
+            logger.info("没有待处理的账号")
+            return 0, 0
+        
+        success_count = 0
+        error_count = 0
+        logger.info(f"开始批量处理 {len(accounts)} 个账号，最大并发数: {max_workers}")
+        
+        # 使用线程池并发处理账号
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_account = {executor.submit(self.submit_email, account): account for account in accounts}
+            
+            for future in concurrent.futures.as_completed(future_to_account):
+                account = future_to_account[future]
+                try:
+                    success = future.result()
+                    if success:
+                        success_count += 1
+                    else:
+                        error_count += 1
+                except Exception as e:
+                    logger.error(f"执行任务时发生异常: {str(e)}")
+                    error_count += 1
+                    # 更新数据库状态
+                    self.db_manager.update_account_status(account['id'], STATUS_FAILED, notes=f"执行异常: {str(e)[:100]}")
+        
+        logger.info(f"批量处理完成，成功: {success_count}，失败: {error_count}")
+        return success_count, error_count
+
+
+class LinkExtractor:
+    """从邮箱中提取JetBrains激活链接的类"""
+    
+    def __init__(self, db_manager: DatabaseManager):
+        """初始化链接提取器
+        
+        Args:
+            db_manager: 数据库管理器实例
+        """
+        self.db_manager = db_manager
+        logger.info("LinkExtractor 初始化完成")
+    
+    def _find_activation_link(self, text_content: str) -> Optional[str]:
+        """在文本内容中查找JetBrains激活链接
+        
+        Args:
+            text_content: 邮件文本内容
+            
+        Returns:
+            找到的激活链接，未找到返回None
+        """
+        if not text_content:
+            return None
+        
+        # 使用正则表达式查找JetBrains激活链接
+        match = re.search(r'https?://(?:account\.jetbrains\.com/login|www\.jetbrains\.com/shop/(?:account|eform)|jetbrains\.com/activate)[?\S]+', text_content)
+        if match:
+            link = match.group(0)
+            # 基本验证：确认是有效的JetBrains激活链接
+            if "jetbrains.com" in link and ("activate" in link or "account" in link or "login" in link or "eform" in link):
+                # 清理链接：移除可能的尾随字符
+                link = link.split('<')[0].split('>')[0].split('"')[0].split("'")[0].strip()
+                logger.info(f"找到可能的激活链接: {link}")
+                return link
+        return None
+    
+    def extract_link(self, account: Dict[str, Any]) -> Optional[str]:
+        """登录邮箱并提取JetBrains激活链接
+        
+        Args:
+            account: 账号信息字典
+            
+        Returns:
+            提取到的激活链接，未找到返回None
+        """
+        username = account['username']
+        password = account['password']
+        logger.info(f"正在尝试登录邮箱: {username} 并提取激活链接...")
+        
+        try:
+            # 创建邮件客户端实例
+            client = EmailClient(
+                username=username,
+                password=password,
+                email_address=username
+            )
+            
+            # 认证
+            logger.info(f"为 {username} 执行OAuth认证...")
+            client.authenticate_oauth()
+            logger.info(f"为 {username} OAuth认证成功")
+            
+            # 搜索邮件
+            logger.info(f"为 {username} 搜索JetBrains相关邮件...")
+            search_keywords = [
+                'BODY "jetbrain"',
+                'SUBJECT "JetBrains Account"',
+                'SUBJECT "Activate JetBrains"',
+                'BODY "jetbrains.com/activate"',
+                'BODY "account.jetbrains.com"',
+                'FROM "jetbrains.com"'
+            ]
+            
+            emails = []
+            for keyword in search_keywords:
+                logger.info(f"使用关键词 '{keyword}' 搜索...")
+                try:
+                    fetched_emails = client.read_emails(mailbox="INBOX", limit=5, keyword=keyword)
+                    emails.extend(fetched_emails)
+                    if emails:  # 找到邮件后停止搜索
+                        logger.info(f"使用关键词 '{keyword}' 找到 {len(fetched_emails)} 封邮件")
+                        break
+                except Exception as read_err:
+                    logger.warning(f"使用关键词 '{keyword}' 读取邮件时出错: {read_err}")
+                time.sleep(1)  # 每次搜索之间短暂延迟
+            
+            if not emails:
+                logger.warning(f"邮箱 {username} 中未找到相关的JetBrains邮件")
+                self.db_manager.update_account_status(account['id'], STATUS_SUBMITTED, notes="没有找到包含关键字的邮件")
+                self.db_manager.log_operation(username, "extract_link", "failed", "没有找到包含关键字的邮件")
+                return None
+            
+            logger.info(f"在 {username} 中找到 {len(emails)} 封相关邮件，开始解析...")
+            
+            # 解析邮件内容
+            for email_content in emails:
+                html_body = email_content.get('html')
+                text_body = email_content.get('text')
+                
+                link = None
+                if html_body:
+                    link = self._find_activation_link(html_body)
+                if not link and text_body:
+                    link = self._find_activation_link(text_body)
+                
+                if link:
+                    logger.success(f"为邮箱 {username} 成功提取到激活链接: {link}")
+                    self.db_manager.update_account_status(account['id'], STATUS_LINK_EXTRACTED, activation_link=link)
+                    self.db_manager.log_operation(username, "extract_link", "success", link)
+                    return link
+            
+            logger.warning(f"在找到的邮件中未能为邮箱 {username} 提取到激活链接")
+            self.db_manager.update_account_status(account['id'], STATUS_SUBMITTED, notes="没有找到激活链接")
+            self.db_manager.log_operation(username, "extract_link", "failed", "在邮件中未找到链接")
+            return None
+            
+        except Exception as e:
+            error_msg = str(e)
+            # 捕获特定认证错误
+            if "Authentication failed" in error_msg or "认证失败" in error_msg:
+                logger.error(f"邮箱 {username} 认证失败: {error_msg}")
+                error_type = "认证失败"
+            elif "invalid_grant" in error_msg:
+                logger.error(f"邮箱 {username} OAuth Token无效或过期: {error_msg}")
+                error_type = "OAuth Token无效"
+            else:
+                logger.error(f"为邮箱 {username} 提取链接时发生未预料的错误: {error_msg}")
+                error_type = "未知错误"
+            
+            self.db_manager.update_account_status(account['id'], STATUS_SUBMITTED, notes=f"{error_type}: {error_msg[:100]}")
+            self.db_manager.log_operation(username, "extract_link", "error", error_msg[:200])
+            return None
+    
+    def extract_batch(self, max_accounts: int = 5, max_workers: int = 1) -> Tuple[int, int]:
+        """批量提取激活链接
+        
+        Args:
+            max_accounts: 最大处理账号数量
+            max_workers: 最大并发线程数
+            
+        Returns:
+            (成功数量, 失败数量)元组
+        """
+        accounts = self.db_manager.get_submitted_accounts(limit=max_accounts)
+        if not accounts:
+            logger.info("没有待提取链接的账号")
+            return 0, 0
+        
+        success_count = 0
+        error_count = 0
+        logger.info(f"开始批量提取链接，处理 {len(accounts)} 个账号，最大并发数: {max_workers}")
+        
+        # 使用线程池并发处理账号
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_account = {executor.submit(self.extract_link, account): account for account in accounts}
+            
+            for future in concurrent.futures.as_completed(future_to_account):
+                account = future_to_account[future]
+                try:
+                    link = future.result()
+                    if link:
+                        success_count += 1
+                    else:
+                        error_count += 1
+                except Exception as e:
+                    logger.error(f"执行提取任务时发生异常: {str(e)}")
+                    error_count += 1
+                    # 更新数据库状态
+                    self.db_manager.update_account_status(account['id'], STATUS_SUBMITTED, notes=f"执行异常: {str(e)[:100]}")
+        
+        logger.info(f"批量提取完成，成功: {success_count}，失败: {error_count}")
+        return success_count, error_count
+
+
+class ProcessController:
+    """流程控制类，协调整个处理流程"""
+    
+    def __init__(self, db_path: str = "unibo_jetbrains.db", proxy: str = ''):
+        """初始化流程控制器
+        
+        Args:
+            db_path: 数据库文件路径
+            proxy: 代理服务器地址
+        """
+        self.db_manager = DatabaseManager(db_path)
+        self.submitter = JetbrainsSubmitter(self.db_manager, proxy)
+        self.extractor = LinkExtractor(self.db_manager)
+        logger.info("ProcessController 初始化完成")
+    
+    def import_data(self, filepath: str) -> int:
+        """从文件导入账号数据
+        
+        Args:
+            filepath: 账号数据文件路径
+            
+        Returns:
+            导入的账号数量
+        """
+        return self.db_manager.import_from_file(filepath)
+    
+    def export_data(self, filepath: str, status: int = None) -> int:
+        """导出账号数据到文件
+        
+        Args:
+            filepath: 输出文件路径
+            status: 筛选状态（可选）
+            
+        Returns:
+            导出的记录数量
+        """
+        return self.db_manager.export_results_to_file(filepath, status)
+    
+    def run_submission_process(self, max_accounts: int = 5, max_workers: int = 3) -> Tuple[int, int]:
+        """运行邮箱提交流程
+        
+        Args:
+            max_accounts: 最大处理账号数量
+            max_workers: 最大并发线程数
+            
+        Returns:
+            (成功数量, 失败数量)元组
+        """
+        return self.submitter.submit_batch(max_accounts, max_workers)
+    
+    def run_extraction_process(self, max_accounts: int = 5, max_workers: int = 1) -> Tuple[int, int]:
+        """运行链接提取流程
+        
+        Args:
+            max_accounts: 最大处理账号数量
+            max_workers: 最大并发线程数
+            
+        Returns:
+            (成功数量, 失败数量)元组
+        """
+        return self.extractor.extract_batch(max_accounts, max_workers)
+    
+    def run_full_process(self, max_submission: int = 5, max_extraction: int = 5, 
+                        submission_workers: int = 3, extraction_workers: int = 1) -> Dict[str, int]:
+        """运行完整流程：提交邮箱并提取链接
+        
+        Args:
+            max_submission: 提交流程最大处理账号数量
+            max_extraction: 提取流程最大处理账号数量
+            submission_workers: 提交流程最大并发线程数
+            extraction_workers: 提取流程最大并发线程数
+            
+        Returns:
+            包含各步骤统计信息的字典
+        """
+        # 运行提交流程
+        sub_success, sub_fail = self.run_submission_process(max_submission, submission_workers)
+        
+        # 运行提取流程
+        ext_success, ext_fail = self.run_extraction_process(max_extraction, extraction_workers)
+        
+        return {
+            'submission_success': sub_success,
+            'submission_fail': sub_fail,
+            'extraction_success': ext_success,
+            'extraction_fail': ext_fail,
+            'total_processed': sub_success + sub_fail + ext_success + ext_fail
+        }
+
+
+# 示例用法
+if __name__ == "__main__":
+    # 设置日志级别
+    logger.remove()
+    logger.add(lambda msg: print(msg, end=""), level="INFO")
+    logger.add("unibo_process.log", rotation="500 KB", level="DEBUG")
+    
+    # 初始化流程控制器
+    controller = ProcessController()
+    
+    # 导入数据
+    print("\n=== 从文件导入数据 ===")
+    imported = controller.import_data("user-4-21-success.txt")
+    print(f"导入了 {imported} 个账号")
+    
+    # 运行提交流程
+    print("\n=== 运行提交邮箱流程 ===")
+    sub_success, sub_fail = controller.run_submission_process(max_accounts=3, max_workers=1)
+    print(f"提交结果: 成功 {sub_success} 个, 失败 {sub_fail} 个")
+    
+    # 运行提取链接流程
+    print("\n=== 运行提取链接流程 ===")
+    ext_success, ext_fail = controller.run_extraction_process(max_accounts=2, max_workers=1)
+    print(f"提取结果: 成功 {ext_success} 个, 失败 {ext_fail} 个")
+    
+    # 导出结果
+    print("\n=== 导出链接提取成功的账号 ===")
+    exported = controller.export_data("export_results.txt", STATUS_LINK_EXTRACTED)
+    print(f"导出了 {exported} 个记录")

收发邮件.py

@@ -0,0 +1,316 @@
+import base64
+import email
+import imaplib
+import smtplib
+import requests
+from email.header import decode_header, Header
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from typing import List, Dict
+from unibo_auth2_get_AuthCode_RefreshToken_sucsses import OAuth2Authenticator
+
+
+class EmailClient:
+    def __init__(self, username: str, password: str, email_address: str):
+        """
+        Initialize the EmailClient with user credentials.
+
+        Args:
+            username: The username for authentication
+            password: The password for authentication
+            email_address: The full email address
+        """
+        self.username = username
+        self.password = password
+        self.email_address = email_address
+        self.client_id = "9e5f94bc-e8a4-4e73-b8be-63364c29d753"
+        self.imap_server = "outlook.office365.com"
+        self.imap_port = 993
+        # self.smtp_server = "submission.unipi.it"  # 使用密码登录
+        self.smtp_server_XOAUTH2 = "smtp.office365.com"  # 使用OAuth2登录
+        self.smtp_port = 587
+        self.refresh_token = None
+        self.access_token = None
+
+    def authenticate_oauth(self) -> None:
+        """Authenticate using OAuth2 and get refresh/access tokens."""
+        authenticator = OAuth2Authenticator(
+            username=self.username,
+            password=self.password
+        )
+
+        try:
+            auth_code = authenticator.execute_flow()
+            print(f"成功获取授权码: {auth_code}")
+            self.refresh_token, self.access_token = authenticator.get_refresh_token(auth_code)
+        except Exception as e:
+            raise Exception(f"认证失败: {e}")
+
+    def _generate_auth_string(self) -> bytes:
+        """Generate XOAUTH2 authentication string."""
+        auth_string = f"user={self.email_address}\x01auth=Bearer {self.access_token}\x01\x01"
+        return auth_string.encode('utf-8')
+
+    def connect_imap(self) -> imaplib.IMAP4:
+        """
+        Connect to IMAP server using XOAUTH2 authentication.
+
+        Returns:
+            IMAP4 connection object
+
+        Raises:
+            Exception: If authentication fails
+        """
+        try:
+            imap = imaplib.IMAP4_SSL(self.imap_server, self.imap_port)
+
+            if 'AUTH=XOAUTH2' not in imap.capabilities:
+                raise Exception("Server does not support XOAUTH2 authentication")
+
+            auth_bytes = self._generate_auth_string()
+
+            def oauth2_callback(response):
+                return auth_bytes
+
+            print(f"Attempting XOAUTH2 authentication as {self.email_address}...")
+            typ, data = imap.authenticate('XOAUTH2', oauth2_callback)
+            if typ != 'OK':
+                raise Exception(f"Authentication failed: {data[0].decode('utf-8', errors='replace')}")
+
+            print("XOAUTH2 authentication successful")
+            return imap
+        except Exception as e:
+            raise Exception(f"IMAP XOAUTH2 authentication failed: {str(e)}")
+
+    def _get_decoded_header(self, header: str) -> str:
+        """解码邮件头信息
+
+        Args:
+            header: 需要解码的邮件头字符串
+
+        Returns:
+            解码后的字符串
+        """
+        try:
+            decoded = decode_header(header)
+
+            # 修复括号匹配问题
+            return "".join(
+                str(
+                    t[0].decode(t[1] or "utf-8", errors="replace")
+                    if isinstance(t[0], bytes)
+                    else t[0]
+                )
+                for t in decoded
+            )
+        except Exception as e:
+            print(f"邮件头解码失败: {str(e)}")
+            return header
+
+    def _parse_email_message(self, msg: email.message.Message) -> Dict:
+        """Parse an email message into a dictionary."""
+        email_data = {}
+
+        # Parse headers
+        email_data["from"] = self._get_decoded_header(msg["from"]) if msg["from"] else "N/A"
+        email_data["subject"] = self._get_decoded_header(msg["subject"]) if msg["subject"] else "N/A"
+        email_data["date"] = msg["date"] if msg["date"] else "N/A"
+        email_data["to"] = self._get_decoded_header(msg.get("to", ""))
+
+        # Parse body content
+        def get_body_content(part):
+            charset = part.get_content_charset() or "utf-8"
+            try:
+                return part.get_payload(decode=True).decode(charset, errors="replace")
+            except Exception as e:
+                print(f"正文解码失败: {str(e)}")
+                return ""
+
+        if msg.is_multipart():
+            for part in msg.walk():
+                content_type = part.get_content_type()
+                content_disposition = str(part.get("Content-Disposition"))
+                if "attachment" in content_disposition:
+                    continue
+                if content_type == "text/plain":
+                    email_data["text"] = get_body_content(part)
+                elif content_type == "text/html":
+                    email_data["html"] = get_body_content(part)
+        else:
+            content_type = msg.get_content_type()
+            if content_type == "text/plain":
+                email_data["text"] = get_body_content(msg)
+            elif content_type == "text/html":
+                email_data["html"] = get_body_content(msg)
+
+        return email_data
+
+    def read_emails(self, mailbox: str = "INBOX", limit: int = 1, keyword: str = 'ALL') -> List[Dict]:
+        """
+        Read emails from the specified mailbox.
+
+        Args:
+            mailbox: Mailbox to read from (default: INBOX)
+            limit: Maximum number of emails to return (default: 1)
+            keyword: Search keyword (default: 'ALL')
+
+        Returns:
+            List of parsed email dictionaries
+        """
+        imap = self.connect_imap()
+        try:
+            status, _ = imap.select(mailbox, readonly=True)
+            if status != 'OK':
+                raise Exception(f"无法选择邮箱 {mailbox}")
+
+            _, messages = imap.search(None, keyword)
+            email_list = []
+            message_ids = messages[0].split()
+
+            if not message_ids:
+                print(f"邮箱 {mailbox} 中没有邮件")
+                return []
+
+            for num in reversed(message_ids[:limit]):
+                _, msg_data = imap.fetch(num, "(RFC822)")
+                email_message = email.message_from_bytes(msg_data[0][1])
+                email_data = self._parse_email_message(email_message)
+                email_data["uid"] = num.decode()
+                email_list.append(email_data)
+
+            print(f"成功读取 {len(email_list)} 封邮件")
+            return email_list
+        finally:
+            imap.logout()
+
+    def send_email(self, receiver: str, subject: str, body: str = None, is_html: bool = True) -> None:
+        """
+        Send an email using SMTP.
+
+        Args:
+            receiver: Recipient email address
+            subject: Email subject
+            body: Email body content
+            is_html: Whether the body is HTML (default: True)
+
+        Raises:
+            Exception: If email sending fails
+        """
+        if body is None:
+            body = """
+            <h1>Python SMTP 测试邮件</h1>
+            <p>这是一封通过Python SMTP发送的测试邮件。</p>
+            """
+            is_html = True
+
+        message = MIMEMultipart()
+        # message['From'] = self.email_address
+        message['To'] = receiver
+        message['Subject'] = subject
+
+        message.attach(MIMEText(body, 'html' if is_html else 'plain', 'utf-8'))
+
+        try:
+            if self.smtp_port == 465:
+                server = smtplib.SMTP_SSL(self.smtp_server_XOAUTH2, self.smtp_port)
+            else:
+                server = smtplib.SMTP(self.smtp_server_XOAUTH2, self.smtp_port)
+                server.starttls()
+
+            # 建立 SMTP 连接
+            server = smtplib.SMTP(self.smtp_server_XOAUTH2, self.smtp_port)
+            # server.set_debuglevel(1)  # 启用调试输出
+            server.ehlo()  # 识别客户端
+            server.starttls()  # 启用TLS加密
+            server.ehlo()  # 再次识别客户端
+            # 准备OAuth2认证字符串
+            auth_string = f"user={self.email_address}\1auth=Bearer {self.access_token}\1\1"
+            auth_string = base64.b64encode(auth_string.encode('utf-8')).decode('utf-8')
+
+            # 执行OAuth2认证
+            code, response = server.docmd('AUTH', 'XOAUTH2 ' + auth_string)
+            server.sendmail(self.email_address, [receiver], message.as_string())
+            print("邮件发送成功")
+        except Exception as e:
+            raise Exception(f"邮件发送失败: {e}")
+        finally:
+            server.quit()
+
+    def refresh_access_token(self) -> str:
+        """
+        Refresh the access token using the refresh token.
+
+        Returns:
+            New access token
+
+        Raises:
+            Exception: If token refresh fails
+        """
+        if not self.refresh_token:
+            raise Exception("No refresh token available")
+
+        url = "https://login.microsoftonline.com/common/oauth2/v2.0/token"
+        headers = {
+            "User-Agent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Thunderbird/137.0',
+            "Content-Type": 'application/x-www-form-urlencoded;charset=UTF-8',
+        }
+        data = {
+            "client_id": self.client_id,
+            "grant_type": "refresh_token",
+            "refresh_token": self.refresh_token,
+            "scope": "https://outlook.office.com/IMAP.AccessAsUser.All offline_access",
+        }
+
+        response = requests.post(url, headers=headers, data=data, verify=False)
+        if response.status_code != 200:
+            error_text = response.text
+            if "invalid_grant" in error_text and "70000" in error_text:
+                print("\n[安全警告] 账户需要安全验证！")
+                print("微软检测到您的账户可能存在安全风险，需要进行额外验证。")
+                print("请登录 https://account.microsoft.com 或 https://account.live.com 进行安全验证")
+                print("验证完成后，您需要重新获取refreshtoken并更新Excel文件\n")
+            raise Exception(f"获取access token失败: {error_text}")
+
+        response_data = response.json()
+        self.access_token = response_data["access_token"]
+        if "refresh_token" in response_data:
+            self.refresh_token = response_data["refresh_token"]
+
+        return self.access_token
+
+
+if __name__ == "__main__":
+    try:
+        # Example usage
+        client = EmailClient(
+            username="[email protected]",
+            password="123",
+            email_address="[email protected]"
+        )
+
+        # Authenticate and get tokens
+        client.authenticate_oauth()
+        #
+        # Read emails with GitHub keyword
+        emails = client.read_emails(mailbox="INBOX",
+                limit=5,keyword='BODY "jetbrain"')
+
+        # Print email details
+        for i, email_data in enumerate(emails, 1):
+            print(f"\n邮件 {i}:")
+            print(f"发件人: {email_data.get('from', 'N/A')}")
+            print(f"主题: {email_data.get('subject', 'N/A')}")
+            print(f"日期: {email_data.get('date', 'N/A')}")
+            print(f"文本内容: {email_data.get('text', 'N/A')[:1000]}...")
+            print("-" * 50)
+
+        # Send a test email
+        # client.send_email(
+        #     receiver="[email protected]",
+        #     subject="Test Email",
+        #     body="This is a test email"
+        # )
+
+    except Exception as e:
+        print(f"Error: {str(e)}")
+