403 lines
15 KiB
Python
403 lines
15 KiB
Python
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
|
from sqlalchemy import func, select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.core.deps import get_current_active_user, get_db, get_optional_current_user
|
|
from app.models.shooting import ShootingApplication, ShootingRequest
|
|
from app.models.user import User
|
|
from app.schemas.common import PageResponse
|
|
from app.schemas.shooting import (
|
|
ApplicationCreate,
|
|
ApplicationOut,
|
|
ShootingRequestBrief,
|
|
ShootingRequestCreate,
|
|
ShootingRequestDetail,
|
|
ShootingRequestUpdate,
|
|
)
|
|
from app.services.notification_service import send_notification
|
|
|
|
router = APIRouter()
|
|
|
|
ROLE_LABELS = {
|
|
"photographer": "摄影师",
|
|
"cosplayer": "Coser",
|
|
"both": "不限",
|
|
}
|
|
|
|
|
|
def _to_brief(sr: ShootingRequest) -> ShootingRequestBrief:
|
|
return ShootingRequestBrief(
|
|
id=sr.id,
|
|
title=sr.title,
|
|
city=sr.city,
|
|
style=sr.style,
|
|
shoot_date=sr.shoot_date,
|
|
is_free=sr.is_free,
|
|
budget_min=float(sr.budget_min) if sr.budget_min is not None else None,
|
|
budget_max=float(sr.budget_max) if sr.budget_max is not None else None,
|
|
role_needed=sr.role_needed,
|
|
status=sr.status,
|
|
audit_status=sr.audit_status,
|
|
creator=sr.creator,
|
|
application_count=len(sr.applications) if sr.applications else 0,
|
|
created_at=sr.created_at,
|
|
)
|
|
|
|
|
|
# --- ShootingRequest CRUD ---
|
|
|
|
@router.post("/", response_model=ShootingRequestBrief, status_code=status.HTTP_201_CREATED)
|
|
async def create_shooting_request(
|
|
payload: ShootingRequestCreate,
|
|
current_user: User = Depends(get_current_active_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
sr = ShootingRequest(
|
|
creator_id=current_user.id,
|
|
title=payload.title,
|
|
city=payload.city,
|
|
description=payload.description,
|
|
style=payload.style,
|
|
shoot_date=payload.shoot_date,
|
|
is_free=payload.is_free,
|
|
budget_min=payload.budget_min if not payload.is_free else None,
|
|
budget_max=payload.budget_max if not payload.is_free else None,
|
|
role_needed=payload.role_needed,
|
|
max_applicants=payload.max_applicants,
|
|
contact_info=payload.contact_info,
|
|
spot_id=payload.spot_id,
|
|
status="open",
|
|
audit_status="pending",
|
|
)
|
|
db.add(sr)
|
|
await db.commit()
|
|
await db.refresh(sr)
|
|
return _to_brief(sr)
|
|
|
|
|
|
@router.get("/", response_model=PageResponse[ShootingRequestBrief])
|
|
async def list_shooting_requests(
|
|
city: str | None = None,
|
|
style: str | None = None,
|
|
role_needed: str | None = None,
|
|
is_free: bool | None = None,
|
|
status_filter: str | None = Query(None, alias="status"),
|
|
page: int = Query(default=1, ge=1),
|
|
page_size: int = Query(default=20, ge=1, le=100),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
base = select(ShootingRequest).where(ShootingRequest.audit_status == "approved")
|
|
count_base = select(func.count(ShootingRequest.id)).where(ShootingRequest.audit_status == "approved")
|
|
|
|
if city:
|
|
base = base.where(ShootingRequest.city.ilike(f"%{city}%"))
|
|
count_base = count_base.where(ShootingRequest.city.ilike(f"%{city}%"))
|
|
if style:
|
|
base = base.where(ShootingRequest.style.ilike(f"%{style}%"))
|
|
count_base = count_base.where(ShootingRequest.style.ilike(f"%{style}%"))
|
|
if role_needed:
|
|
base = base.where(ShootingRequest.role_needed == role_needed)
|
|
count_base = count_base.where(ShootingRequest.role_needed == role_needed)
|
|
if is_free is not None:
|
|
base = base.where(ShootingRequest.is_free == is_free)
|
|
count_base = count_base.where(ShootingRequest.is_free == is_free)
|
|
if status_filter:
|
|
base = base.where(ShootingRequest.status == status_filter)
|
|
count_base = count_base.where(ShootingRequest.status == status_filter)
|
|
|
|
total = (await db.execute(count_base)).scalar() or 0
|
|
offset = (page - 1) * page_size
|
|
result = await db.execute(base.order_by(ShootingRequest.created_at.desc()).offset(offset).limit(page_size))
|
|
items = result.scalars().all()
|
|
|
|
return PageResponse(total=total, items=[_to_brief(sr) for sr in items])
|
|
|
|
|
|
@router.get("/mine", response_model=PageResponse[ShootingRequestBrief])
|
|
async def list_my_shooting_requests(
|
|
page: int = Query(default=1, ge=1),
|
|
page_size: int = Query(default=20, ge=1, le=100),
|
|
current_user: User = Depends(get_current_active_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
base = select(ShootingRequest).where(ShootingRequest.creator_id == current_user.id)
|
|
count_base = select(func.count(ShootingRequest.id)).where(ShootingRequest.creator_id == current_user.id)
|
|
|
|
total = (await db.execute(count_base)).scalar() or 0
|
|
offset = (page - 1) * page_size
|
|
result = await db.execute(base.order_by(ShootingRequest.created_at.desc()).offset(offset).limit(page_size))
|
|
items = result.scalars().all()
|
|
|
|
return PageResponse(total=total, items=[_to_brief(sr) for sr in items])
|
|
|
|
|
|
@router.get("/my-applications", response_model=PageResponse[ApplicationOut])
|
|
async def list_my_applications(
|
|
page: int = Query(default=1, ge=1),
|
|
page_size: int = Query(default=20, ge=1, le=100),
|
|
current_user: User = Depends(get_current_active_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
base = select(ShootingApplication).where(ShootingApplication.applicant_id == current_user.id)
|
|
count_base = select(func.count(ShootingApplication.id)).where(ShootingApplication.applicant_id == current_user.id)
|
|
|
|
total = (await db.execute(count_base)).scalar() or 0
|
|
offset = (page - 1) * page_size
|
|
result = await db.execute(base.order_by(ShootingApplication.created_at.desc()).offset(offset).limit(page_size))
|
|
items = result.scalars().all()
|
|
|
|
return PageResponse(total=total, items=items)
|
|
|
|
|
|
@router.get("/{request_id}", response_model=ShootingRequestDetail)
|
|
async def get_shooting_request(
|
|
request_id: int,
|
|
current_user: User | None = Depends(get_optional_current_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
result = await db.execute(select(ShootingRequest).where(ShootingRequest.id == request_id))
|
|
sr = result.scalar_one_or_none()
|
|
if not sr:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
|
|
|
|
has_applied = False
|
|
if current_user:
|
|
app_result = await db.execute(
|
|
select(ShootingApplication).where(
|
|
ShootingApplication.request_id == request_id,
|
|
ShootingApplication.applicant_id == current_user.id,
|
|
)
|
|
)
|
|
has_applied = app_result.scalar_one_or_none() is not None
|
|
|
|
return ShootingRequestDetail(
|
|
id=sr.id,
|
|
title=sr.title,
|
|
city=sr.city,
|
|
style=sr.style,
|
|
shoot_date=sr.shoot_date,
|
|
is_free=sr.is_free,
|
|
budget_min=float(sr.budget_min) if sr.budget_min is not None else None,
|
|
budget_max=float(sr.budget_max) if sr.budget_max is not None else None,
|
|
role_needed=sr.role_needed,
|
|
status=sr.status,
|
|
audit_status=sr.audit_status,
|
|
creator=sr.creator,
|
|
application_count=len(sr.applications) if sr.applications else 0,
|
|
created_at=sr.created_at,
|
|
description=sr.description,
|
|
max_applicants=sr.max_applicants,
|
|
contact_info=sr.contact_info if (current_user and (sr.creator_id == current_user.id or current_user.role in ("admin", "moderator"))) else None,
|
|
spot_id=sr.spot_id,
|
|
reject_reason=sr.reject_reason,
|
|
has_applied=has_applied,
|
|
)
|
|
|
|
|
|
@router.put("/{request_id}", response_model=ShootingRequestBrief)
|
|
async def update_shooting_request(
|
|
request_id: int,
|
|
payload: ShootingRequestUpdate,
|
|
current_user: User = Depends(get_current_active_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
result = await db.execute(select(ShootingRequest).where(ShootingRequest.id == request_id))
|
|
sr = result.scalar_one_or_none()
|
|
if not sr:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
|
|
if sr.creator_id != current_user.id and current_user.role not in ("admin", "moderator"):
|
|
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not allowed")
|
|
|
|
update_data = payload.model_dump(exclude_unset=True)
|
|
for field, value in update_data.items():
|
|
setattr(sr, field, value)
|
|
await db.commit()
|
|
await db.refresh(sr)
|
|
return _to_brief(sr)
|
|
|
|
|
|
@router.post("/{request_id}/close")
|
|
async def close_shooting_request(
|
|
request_id: int,
|
|
current_user: User = Depends(get_current_active_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
result = await db.execute(select(ShootingRequest).where(ShootingRequest.id == request_id))
|
|
sr = result.scalar_one_or_none()
|
|
if not sr:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
|
|
if sr.creator_id != current_user.id and current_user.role not in ("admin", "moderator"):
|
|
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not allowed")
|
|
|
|
sr.status = "closed"
|
|
await db.commit()
|
|
return {"code": 0, "message": "closed"}
|
|
|
|
|
|
# --- Applications ---
|
|
|
|
@router.post("/{request_id}/apply", response_model=ApplicationOut, status_code=status.HTTP_201_CREATED)
|
|
async def apply_to_shooting(
|
|
request_id: int,
|
|
payload: ApplicationCreate,
|
|
current_user: User = Depends(get_current_active_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
result = await db.execute(select(ShootingRequest).where(ShootingRequest.id == request_id))
|
|
sr = result.scalar_one_or_none()
|
|
if not sr:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
|
|
if sr.status != "open":
|
|
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="该约拍已关闭")
|
|
if sr.audit_status != "approved":
|
|
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="该约拍尚未通过审核")
|
|
if sr.creator_id == current_user.id:
|
|
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="不能报名自己的约拍")
|
|
|
|
existing = await db.execute(
|
|
select(ShootingApplication).where(
|
|
ShootingApplication.request_id == request_id,
|
|
ShootingApplication.applicant_id == current_user.id,
|
|
)
|
|
)
|
|
if existing.scalar_one_or_none():
|
|
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="已经报名过了")
|
|
|
|
app = ShootingApplication(
|
|
request_id=request_id,
|
|
applicant_id=current_user.id,
|
|
message=payload.message,
|
|
status="pending",
|
|
)
|
|
db.add(app)
|
|
|
|
await send_notification(
|
|
db, sr.creator_id, "shooting",
|
|
f"有人报名了您的约拍「{sr.title}」",
|
|
content=f"{current_user.nickname} 报名了您的约拍",
|
|
ref_type="shooting", ref_id=sr.id,
|
|
)
|
|
|
|
await db.commit()
|
|
await db.refresh(app)
|
|
return app
|
|
|
|
|
|
@router.get("/{request_id}/applications", response_model=list[ApplicationOut])
|
|
async def list_applications(
|
|
request_id: int,
|
|
current_user: User = Depends(get_current_active_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
result = await db.execute(select(ShootingRequest).where(ShootingRequest.id == request_id))
|
|
sr = result.scalar_one_or_none()
|
|
if not sr:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
|
|
if sr.creator_id != current_user.id and current_user.role not in ("admin", "moderator"):
|
|
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Only creator can view applications")
|
|
|
|
result = await db.execute(
|
|
select(ShootingApplication)
|
|
.where(ShootingApplication.request_id == request_id)
|
|
.order_by(ShootingApplication.created_at.desc())
|
|
)
|
|
return result.scalars().all()
|
|
|
|
|
|
@router.post("/{request_id}/applications/{app_id}/accept")
|
|
async def accept_application(
|
|
request_id: int,
|
|
app_id: int,
|
|
current_user: User = Depends(get_current_active_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
sr_result = await db.execute(select(ShootingRequest).where(ShootingRequest.id == request_id))
|
|
sr = sr_result.scalar_one_or_none()
|
|
if not sr or sr.creator_id != current_user.id:
|
|
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not allowed")
|
|
|
|
app_result = await db.execute(
|
|
select(ShootingApplication).where(
|
|
ShootingApplication.id == app_id,
|
|
ShootingApplication.request_id == request_id,
|
|
)
|
|
)
|
|
app = app_result.scalar_one_or_none()
|
|
if not app:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Application not found")
|
|
if app.status != "pending":
|
|
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="该报名已被处理")
|
|
|
|
app.status = "accepted"
|
|
|
|
accepted_count = sum(1 for a in sr.applications if a.status == "accepted") + 1
|
|
if accepted_count >= sr.max_applicants:
|
|
sr.status = "matched"
|
|
|
|
await send_notification(
|
|
db, app.applicant_id, "shooting",
|
|
f"您的约拍报名「{sr.title}」已被接受",
|
|
content="对方已接受您的报名，请查看详情。",
|
|
ref_type="shooting", ref_id=sr.id,
|
|
)
|
|
|
|
await db.commit()
|
|
return {"code": 0, "message": "accepted"}
|
|
|
|
|
|
@router.post("/{request_id}/applications/{app_id}/reject")
|
|
async def reject_application(
|
|
request_id: int,
|
|
app_id: int,
|
|
current_user: User = Depends(get_current_active_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
sr_result = await db.execute(select(ShootingRequest).where(ShootingRequest.id == request_id))
|
|
sr = sr_result.scalar_one_or_none()
|
|
if not sr or sr.creator_id != current_user.id:
|
|
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not allowed")
|
|
|
|
app_result = await db.execute(
|
|
select(ShootingApplication).where(
|
|
ShootingApplication.id == app_id,
|
|
ShootingApplication.request_id == request_id,
|
|
)
|
|
)
|
|
app = app_result.scalar_one_or_none()
|
|
if not app:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Application not found")
|
|
|
|
app.status = "rejected"
|
|
|
|
await send_notification(
|
|
db, app.applicant_id, "shooting",
|
|
f"您的约拍报名「{sr.title}」未通过",
|
|
ref_type="shooting", ref_id=sr.id,
|
|
)
|
|
|
|
await db.commit()
|
|
return {"code": 0, "message": "rejected"}
|
|
|
|
|
|
@router.delete("/{request_id}/applications/withdraw")
|
|
async def withdraw_application(
|
|
request_id: int,
|
|
current_user: User = Depends(get_current_active_user),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
result = await db.execute(
|
|
select(ShootingApplication).where(
|
|
ShootingApplication.request_id == request_id,
|
|
ShootingApplication.applicant_id == current_user.id,
|
|
)
|
|
)
|
|
app = result.scalar_one_or_none()
|
|
if not app:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Application not found")
|
|
if app.status == "accepted":
|
|
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="已被接受的报名无法撤回")
|
|
|
|
await db.delete(app)
|
|
await db.commit()
|
|
return {"code": 0, "message": "withdrawn"}
|