Merge branch 'main' of https://gitee.com/wg123/video-gen

2026-06-26 13:47:14 +08:00
parent ee03242e6c f7a5ec4b58
commit 479e1a91fb
32 changed files with 1983 additions and 1215 deletions
@@ -25,6 +25,7 @@ from app.api.v1.pre_test_template import router as pre_test_template_router
 from app.api.v1.material_consumption import router as material_consumption_router
 from app.api.v1.open_type import router as open_type_router
 from app.api.v1.resources_material import router as resources_material_router
+from app.api.v1.contact import router as contact_router
 from app.api.admin import router as admin_module_router

 api_router = APIRouter()
@@ -53,4 +54,5 @@ api_router.include_router(pre_test_template_router)
 api_router.include_router(material_consumption_router)
 api_router.include_router(open_type_router)
 api_router.include_router(resources_material_router)
+api_router.include_router(contact_router)
 api_router.include_router(admin_module_router)
@@ -10,6 +10,7 @@ from app.dependencies import (
    get_current_user_allow_password_pending,
    get_db,
 )
+from app.models.credit_record import CreditRecord
 from app.models.system_config import SystemConfig
 from app.models.user import User
 from app.schemas.auth import (
@@ -86,6 +87,20 @@ async def _get_register_credits(db: AsyncSession) -> int:
    return int(value) if value else 100


+async def _add_register_credit_record(db: AsyncSession, user: User, credits: int) -> None:
+    if credits <= 0:
+        return
+    record = CreditRecord(
+        id=generate_id(),
+        user_id=user.id,
+        type="recharge",
+        amount=credits,
+        balance_after=user.credits,
+        description=f"注册赠送 {credits} 积分",
+    )
+    db.add(record)
+
+
 async def _handle_daily_login_credits(db: AsyncSession, user: User) -> None:
    enabled_result = await db.execute(
        select(SystemConfig.value).where(SystemConfig.key == "user_login_credits_enabled").limit(1)
@@ -108,6 +123,16 @@ async def _handle_daily_login_credits(db: AsyncSession, user: User) -> None:
            return
    
    user.credits += credits
+    
+    record = CreditRecord(
+        id=generate_id(),
+        user_id=user.id,
+        type="recharge",
+        amount=credits,
+        balance_after=user.credits,
+        description=f"每日登录赠送 {credits} 积分",
+    )
+    db.add(record)


@router.post(
@@ -204,6 +229,7 @@ async def register(req: RegisterRequest, db: AsyncSession = Depends(get_db)):
    db.add(user)
    await db.flush()

+    await _add_register_credit_record(db, user, register_credits)
    await _assign_default_frontend_menus(db, user)

    user.credits = round(user.credits, 2)
@@ -0,0 +1,140 @@
+from datetime import datetime, timezone, timedelta
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.dependencies import get_db, get_current_user
+from app.models.contact_request import ContactRequest
+from app.models.user import User
+from app.schemas.contact import ContactRequestCreate, ContactRequestListOut, ContactRequestOut
+from app.utils.id_gen import generate_id
+
+router = APIRouter(prefix="/contact", tags=["contact"])
+
+
+@router.post("/request", summary="提交联系请求", status_code=status.HTTP_201_CREATED)
+async def create_contact_request(
+    request: ContactRequestCreate,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    today_start = datetime.now(timezone.utc).replace(hour=0, minute=0, second=0, microsecond=0)
+    today_end = today_start + timedelta(days=1)
+    
+    count = await db.execute(
+        select(func.count(ContactRequest.id))
+        .where(ContactRequest.user_id == user.id)
+        .where(ContactRequest.created_at >= today_start)
+        .where(ContactRequest.created_at < today_end)
+    )
+    daily_count = count.scalar_one()
+    
+    if daily_count >= 1:
+        raise HTTPException(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            detail="每个账号每天只能提交一次联系我们"
+        )
+    
+    contact_request = ContactRequest(
+        id=generate_id(),
+        user_id=user.id,
+        phone=request.phone,
+        company_name=request.company_name,
+        industry=request.industry,
+        name=request.name,
+        message=request.message,
+    )
+    
+    db.add(contact_request)
+    await db.commit()
+    await db.refresh(contact_request)
+    
+    return {"message": "提交成功，我们会尽快与您联系"}
+
+
+@router.get("/requests", summary="获取联系请求列表", response_model=ContactRequestListOut)
+async def get_contact_requests(
+    page: int = 1,
+    page_size: int = 20,
+    is_handled: bool | None = None,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    if not user.is_admin:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="无权限")
+    
+    query = select(ContactRequest).order_by(ContactRequest.created_at.desc())
+    
+    if is_handled is not None:
+        query = query.where(ContactRequest.is_handled == is_handled)
+    
+    offset = (page - 1) * page_size
+    result = await db.execute(query.offset(offset).limit(page_size))
+    items = result.scalars().all()
+    
+    count_result = await db.execute(select(func.count(ContactRequest.id)))
+    total = count_result.scalar_one()
+    
+    return {"items": items, "total": total}
+
+
+@router.get("/requests/{request_id}", summary="获取联系请求详情", response_model=ContactRequestOut)
+async def get_contact_request(
+    request_id: str,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    if not user.is_admin:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="无权限")
+    
+    result = await db.execute(select(ContactRequest).where(ContactRequest.id == request_id))
+    contact_request = result.scalar_one_or_none()
+    
+    if not contact_request:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="记录不存在")
+    
+    return contact_request
+
+
+@router.put("/requests/{request_id}/handle", summary="标记为已处理")
+async def mark_as_handled(
+    request_id: str,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    if not user.is_admin:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="无权限")
+    
+    result = await db.execute(select(ContactRequest).where(ContactRequest.id == request_id))
+    contact_request = result.scalar_one_or_none()
+    
+    if not contact_request:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="记录不存在")
+    
+    contact_request.is_handled = True
+    await db.commit()
+    await db.refresh(contact_request)
+    
+    return {"message": "已标记为处理"}
+
+
+@router.delete("/requests/{request_id}", summary="删除联系请求")
+async def delete_contact_request(
+    request_id: str,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    if not user.is_admin:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="无权限")
+    
+    result = await db.execute(select(ContactRequest).where(ContactRequest.id == request_id))
+    contact_request = result.scalar_one_or_none()
+    
+    if not contact_request:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="记录不存在")
+    
+    await db.delete(contact_request)
+    await db.commit()
+    
+    return {"message": "删除成功"}
@@ -55,144 +55,152 @@ async def async_batch_upload_material(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
 ) -> Any | dict:
-    if not req.tasks:
+    try:
+        if not req.tasks:
+            return {
+                "code": 0,
+                "message": "上传任务列表不能为空",
+                "task_ids": [],
+                "errors": [],
+            }
+
+        task_ids = []
+        errors = []
+        
+        source_model_map = {
+            "generation_records": "GenerationRecord",
+            "generated_resources": None,
+            "chat_generation_tasks": "ChatGenerationTask",
+        }
+
+        for task_index, task in enumerate(req.tasks, 1):
+            if not task.advertiser_ids:
+                errors.append({
+                    "task_index": task_index,
+                    "error": "广告主id数组不能为空",
+                })
+                continue
+            
+            if not task.resource_ids:
+                errors.append({
+                    "task_index": task_index,
+                    "error": "资源id数组不能为空",
+                })
+                continue
+            
+            if task.is_pre_test == "1" and not task.pre_test_template:
+                errors.append({
+                    "task_index": task_index,
+                    "error": "开启前测功能时，必须指定前测模板id",
+                })
+                continue
+            
+            if task.is_pre_test == "1":
+                template = await db.execute(
+                    select(PreTestTemplate).where(PreTestTemplate.id == task.pre_test_template).
+                    where(PreTestTemplate.deleted_at.is_(None)).
+                    where(PreTestTemplate.user_id == current_user.id)
+                )
+                template = template.scalar_one_or_none()
+                if not template:
+                    errors.append({
+                        "task_index": task_index,
+                        "error": "前测模板id不存在",
+                    })
+                    continue
+            
+            target_source_model = source_model_map.get(task.source_model)
+            
+            # 检查资源id是否存在，非资源id
+            if target_source_model:
+                query = (
+                    select(GeneratedResource.id)
+                    .where(GeneratedResource.source_model == target_source_model)
+                    .where(GeneratedResource.source_id.in_(task.resource_ids))
+                    .where(GeneratedResource.user_id == current_user.id)
+                    .where(GeneratedResource.deleted_at.is_(None))
+                )
+                result = await db.execute(query)
+                valid_resource_ids = [row[0] for row in result.all()]
+                
+                invalid_ids = set(task.resource_ids) - set(valid_resource_ids)
+                
+                if invalid_ids:
+                    invalid_ids_str = ", ".join(invalid_ids)
+                    errors.append({
+                        "task_index": task_index,
+                        "error": f"资源id [{invalid_ids_str}] 不可用或已删除",
+                    })
+                    continue
+                
+                resource_ids_to_upload = valid_resource_ids
+            else:
+                #用户提交的直接是资源id
+                query = (
+                    select(GeneratedResource.id)
+                    .where(GeneratedResource.id.in_(task.resource_ids))
+                    .where(GeneratedResource.user_id == current_user.id)
+                    .where(GeneratedResource.deleted_at.is_(None))
+                )
+                result = await db.execute(query)
+                valid_resource_ids = [row[0] for row in result.all()]
+                
+                invalid_ids = set(task.resource_ids) - set(valid_resource_ids)
+                
+                if invalid_ids:
+                    invalid_ids_str = ", ".join(invalid_ids)
+                    errors.append({
+                        "task_index": task_index,
+                        "error": f"资源id [{invalid_ids_str}] 不可用或已删除",
+                    })
+                    continue
+                
+                resource_ids_to_upload = valid_resource_ids
+            
+            for advertiser_id in task.advertiser_ids:
+                for resource_id in resource_ids_to_upload:
+                    other_info = {}
+                    if task.is_pre_test == "1":
+                        other_info["is_pre_test"] = task.is_pre_test
+                        other_info["pre_test_template"] = task.pre_test_template
+
+                    task_id = generate_id()
+                    upload_task = UploadTask(
+                        id=task_id,
+                        user_id=current_user.id,
+                        oauth_id=task.oauth_id,
+                        advertiser_id=advertiser_id,
+                        resource_id=resource_id,
+                        status=1,
+                        note=None,
+                        other_info=json.dumps(other_info) if other_info else None,
+                    )
+                    
+                    db.add(upload_task)
+                    await upload_queue.enqueue(task_id)
+                    task_ids.append(task_id)
+        
+        await db.commit()
+        
+        message = "上传任务已提交"
+        if errors:
+            message = f"部分任务提交成功，{len(errors)} 个任务失败"
+        
        return {
            "code": 0,
-            "message": "上传任务列表不能为空",
+            "message": message,
+            "task_ids": task_ids,
+            "errors": errors,
+        }
+
+    except Exception as e:
+        return {
+            "code": 1,
+            "message": str(e),
            "task_ids": [],
            "errors": [],
        }

-    task_ids = []
-    errors = []
-    
-    source_model_map = {
-        "generation_records": "GenerationRecord",
-        "generated_resources": None,
-        "chat_generation_tasks": "ChatGenerationTask",
-    }
-
-    for task_index, task in enumerate(req.tasks, 1):
-        if not task.advertiser_ids:
-            errors.append({
-                "task_index": task_index,
-                "error": "广告主id数组不能为空",
-            })
-            continue
-        
-        if not task.resource_ids:
-            errors.append({
-                "task_index": task_index,
-                "error": "资源id数组不能为空",
-            })
-            continue
-        
-        if task.is_pre_test == "1" and not task.pre_test_template:
-            errors.append({
-                "task_index": task_index,
-                "error": "开启前测功能时，必须指定前测模板id",
-            })
-            continue
-        
-        if task.is_pre_test == "1":
-            template = await db.execute(
-                select(PreTestTemplate).where(PreTestTemplate.id == task.pre_test_template).
-                where(PreTestTemplate.deleted_at.is_(None)).
-                where(PreTestTemplate.user_id == current_user.id)
-            )
-            template = template.scalar_one_or_none()
-            if not template:
-                errors.append({
-                    "task_index": task_index,
-                    "error": "前测模板id不存在",
-                })
-                continue
-        
-        target_source_model = source_model_map.get(task.source_model)
-        
-        # 检查资源id是否存在，非资源id
-        if target_source_model:
-            query = (
-                select(GeneratedResource.id)
-                .where(GeneratedResource.source_model == target_source_model)
-                .where(GeneratedResource.source_id.in_(task.resource_ids))
-                .where(GeneratedResource.user_id == current_user.id)
-                .where(GeneratedResource.deleted_at.is_(None))
-            )
-            result = await db.execute(query)
-            valid_resource_ids = [row[0] for row in result.all()]
-            
-            invalid_ids = set(task.resource_ids) - set(valid_resource_ids)
-            
-            if invalid_ids:
-                invalid_ids_str = ", ".join(invalid_ids)
-                errors.append({
-                    "task_index": task_index,
-                    "error": f"资源id [{invalid_ids_str}] 不可用或已删除",
-                })
-                continue
-            
-            resource_ids_to_upload = valid_resource_ids
-        else:
-            #用户提交的直接是资源id
-            query = (
-                select(GeneratedResource.id)
-                .where(GeneratedResource.id.in_(task.resource_ids))
-                .where(GeneratedResource.user_id == current_user.id)
-                .where(GeneratedResource.deleted_at.is_(None))
-            )
-            result = await db.execute(query)
-            valid_resource_ids = [row[0] for row in result.all()]
-            
-            invalid_ids = set(task.resource_ids) - set(valid_resource_ids)
-            
-            if invalid_ids:
-                invalid_ids_str = ", ".join(invalid_ids)
-                errors.append({
-                    "task_index": task_index,
-                    "error": f"资源id [{invalid_ids_str}] 不可用或已删除",
-                })
-                continue
-            
-            resource_ids_to_upload = valid_resource_ids
-        
-        for advertiser_id in task.advertiser_ids:
-            for resource_id in resource_ids_to_upload:
-                other_info = {}
-                if task.is_pre_test == "1":
-                    other_info["is_pre_test"] = task.is_pre_test
-                    other_info["pre_test_template"] = task.pre_test_template
-
-                task_id = generate_id()
-                upload_task = UploadTask(
-                    id=task_id,
-                    user_id=current_user.id,
-                    oauth_id=task.oauth_id,
-                    advertiser_id=advertiser_id,
-                    resource_id=resource_id,
-                    status=1,
-                    note=None,
-                    other_info=json.dumps(other_info) if other_info else None,
-                )
-                
-                db.add(upload_task)
-                await upload_queue.enqueue(task_id)
-                task_ids.append(task_id)
-    
-    await db.commit()
-    
-    message = "上传任务已提交"
-    if errors:
-        message = f"部分任务提交成功，{len(errors)} 个任务失败"
-    
-    return {
-        "code": 0,
-        "message": message,
-        "task_ids": task_ids,
-        "errors": errors,
-    }
-
-
@router.post(
    "/batch-update-filename",
    summary="批量修改资源文件名",