# 创建一个用户管理API，包含CRUD操作和JWT认证
from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
from sqlalchemy.orm import Session
from pydantic import BaseModel, EmailStr
from typing import Optional, List
from datetime import datetime, timedelta
import jwt

app = FastAPI(title="用户管理系统")
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
SECRET_KEY = "your-secret-key"
ALGORITHM = "HS256"

class UserCreate(BaseModel):
    username: str
    email: EmailStr
    password: str

class UserResponse(BaseModel):
    id: int
    username: str
    email: str
    created_at: datetime

    class Config:
        from_attributes = True

def get_current_user(token: str = Depends(oauth2_scheme)):
    """验证JWT令牌并返回当前用户"""
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise HTTPException(status_code=401, detail="无效的认证凭据")
    except jwt.PyJWTError:
        raise HTTPException(status_code=401, detail="无效的认证凭据")
    return username

@app.post("/users/", response_model=UserResponse, status_code=201)
def create_user(user: UserCreate, db: Session = Depends(get_db)):
    """创建新用户"""
    db_user = get_user_by_email(db, email=user.email)
    if db_user:
        raise HTTPException(status_code=400, detail="邮箱已注册")
    return create_user_in_db(db=db, user=user)

@app.get("/users/", response_model=List[UserResponse])
def list_users(
    skip: int = 0,
    limit: int = 100,
    current_user: str = Depends(get_current_user)
):
    """获取用户列表（需要认证）"""
    return get_users(db, skip=skip, limit=limit)

import pytest
from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_create_user_success():
    """测试成功创建用户"""
    response = client.post("/users/", json={
        "username": "testuser",
        "email": "test@example.com",
        "password": "SecurePass123!"
    })
    assert response.status_code == 201
    data = response.json()
    assert data["username"] == "testuser"
    assert "id" in data

def test_create_duplicate_user():
    """测试重复邮箱注册"""
    client.post("/users/", json={
        "username": "user1",
        "email": "dup@example.com",
        "password": "Password123!"
    })
    response = client.post("/users/", json={
        "username": "user2",
        "email": "dup@example.com",
        "password": "Password456!"
    })
    assert response.status_code == 400
    assert "邮箱已注册" in response.json()["detail"]

def test_list_users_unauthorized():
    """测试未认证访问用户列表"""
    response = client.get("/users/")
    assert response.status_code == 401

# 原始代码：一个混乱的数据处理脚本
def process_data(data):
    result = []
    for item in data:
        if item['age'] > 18:
            if item['score'] > 60:
                result.append({
                    'name': item['name'],
                    'age': item['age'],
                    'score': item['score'],
                    'level': 'pass' if item['score'] > 80 else 'average'
                })
    return result

# Cline重构后的代码
import logging
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Callable, List, Any

logger = logging.getLogger(__name__)

@dataclass
class Person:
    name: str
    age: int
    score: float

class FilterStrategy(ABC):
    """过滤策略抽象基类"""
    @abstractmethod
    def is_valid(self, person: Person) -> bool:
        pass

class AdultFilter(FilterStrategy):
    def is_valid(self, person: Person) -> bool:
        result = person.age > 18
        logger.debug(f"AdultFilter: {person.name} -> {result}")
        return result

class ScoreFilter(FilterStrategy):
    def __init__(self, min_score: float = 60.0):
        self.min_score = min_score

    def is_valid(self, person: Person) -> bool:
        result = person.score > self.min_score
        logger.debug(f"ScoreFilter: {person.name} ({person.score}) -> {result}")
        return result

class TransformStrategy(ABC):
    """转换策略抽象基类"""
    @abstractmethod
    def transform(self, person: Person) -> dict:
        pass

class LevelTransformer(TransformStrategy):
    def transform(self, person: Person) -> dict:
        level = 'excellent' if person.score > 90 else (
            'good' if person.score > 80 else 'average'
        )
        return {
            'name': person.name,
            'age': person.age,
            'score': person.score,
            'level': level,
        }

class DataPipeline:
    """可组合的数据处理管道"""
    def __init__(self):
        self._filters: List[FilterStrategy] = []
        self._transformer: TransformStrategy | None = None

    def add_filter(self, strategy: FilterStrategy) -> 'DataPipeline':
        self._filters.append(strategy)
        return self

    def set_transformer(self, strategy: TransformStrategy) -> 'DataPipeline':
        self._transformer = strategy
        return self

    def process(self, data: List[dict]) -> List[dict]:
        logger.info(f"开始处理数据，共 {len(data)} 条记录")
        persons = [Person(**item) for item in data]

        # 应用所有过滤器
        filtered = persons
        for f in self._filters:
            before_count = len(filtered)
            filtered = [p for p in filtered if f.is_valid(p)]
            logger.info(f"过滤器 {f.__class__.__name__}: "
                       f"{before_count} -> {len(filtered)}")

        # 应用转换
        if self._transformer:
            result = [self._transformer.transform(p) for p in filtered]
        else:
            result = [vars(p) for p in filtered]

        logger.info(f"处理完成，输出 {len(result)} 条记录")
        return result

# 使用示例
pipeline = (
    DataPipeline()
    .add_filter(AdultFilter())
    .add_filter(ScoreFilter(min_score=60))
    .set_transformer(LevelTransformer())
)

results = pipeline.process(raw_data)

# 使用Amazon Q Developer生成AWS Lambda + DynamoDB的CRUD操作
import boto3
from boto3.dynamodb.conditions import Key, Attr
from datetime import datetime
import uuid

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Products')

class ProductService:
    """产品服务 - 管理产品的CRUD操作"""

    def create_product(self, name: str, price: float,
                       description: str = "") -> dict:
        """创建新产品"""
        product_id = str(uuid.uuid4())
        item = {
            'product_id': product_id,
            'name': name,
            'price': price,
            'description': description,
            'created_at': datetime.utcnow().isoformat(),
            'updated_at': datetime.utcnow().isoformat(),
            'status': 'active',
        }
        table.put_item(Item=item)
        logger.info(f"创建产品: {product_id} - {name}")
        return item

    def get_product(self, product_id: str) -> dict | None:
        """根据ID获取产品"""
        response = table.get_item(Key={'product_id': product_id})
        return response.get('Item')

    def search_products(self, category: str = None,
                        min_price: float = None) -> list:
        """搜索产品，支持按类别和价格范围筛选"""
        filter_expr = Attr('status').eq('active')

        if min_price is not None:
            filter_expr = filter_expr & Attr('price').gte(min_price)

        response = table.scan(FilterExpression=filter_expr)
        return response.get('Items', [])

    def update_product(self, product_id: str,
                       **kwargs) -> dict:
        """更新产品信息"""
        update_expr_parts = []
        expression_values = {}

        allowed_fields = {'name', 'price', 'description', 'status'}
        for field, value in kwargs.items():
            if field in allowed_fields:
                update_expr_parts.append(f"{field} = :{field}")
                expression_values[f":{field}"] = value

        if not update_expr_parts:
            raise ValueError("没有提供有效的更新字段")

        update_expr_parts.append("updated_at = :updated_at")
        expression_values[":updated_at"] = datetime.utcnow().isoformat()

        response = table.update_item(
            Key={'product_id': product_id},
            UpdateExpression="SET " + ", ".join(update_expr_parts),
            ExpressionAttributeValues=expression_values,
            ReturnValues="ALL_NEW",
        )
        return response.get('Attributes')