548f91c37f
- 移除后端产品、目的地、活动专题等废弃模块的数据库表与业务代码，删除冗余API接口 - 删除小程序端详情页、线路组件等冗余代码，移除搜索工具与测试用例，调整导航逻辑 - 清理管理端废弃的类型定义、编辑器与测试代码 - 更新项目文档，修正模块维护说明与接口文档内容
639 lines
23 KiB
Python
639 lines
23 KiB
Python
import base64
|
|
import hashlib
|
|
import hmac
|
|
import http.client
|
|
import os
|
|
import re
|
|
from email.utils import formatdate
|
|
from uuid import uuid4
|
|
from urllib.parse import quote, urlsplit, urlunsplit
|
|
from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, Request, UploadFile, status
|
|
from sqlalchemy import func, or_, select
|
|
from sqlalchemy.orm import Session, selectinload
|
|
from ..auth import create_token, get_actor_id, require_admin, verify_password
|
|
from ..config import get_settings
|
|
from ..database import get_db
|
|
from ..models import (
|
|
AdminUser,
|
|
AuditLog,
|
|
DemandFeatureCard,
|
|
DemandForm,
|
|
DemandHero,
|
|
DestinationHero,
|
|
HeroSlide,
|
|
Lead,
|
|
MediaAsset,
|
|
SiteVersion,
|
|
VehicleOption,
|
|
utc_now,
|
|
)
|
|
from ..schemas import LeadQuery, LeadStatus, LeadStatusIn, LoginIn, SiteConfigPatchIn, SiteConfigReorderIn
|
|
from ..seed import create_media, reset_guizhou_content
|
|
from ..serializers import encode_value, lead_dict, model_dict
|
|
from .shared import site_config
|
|
|
|
|
|
router = APIRouter(prefix="/api/admin")
|
|
|
|
MEDIA_UPLOAD_MAX_BYTES = 5 * 1024 * 1024
|
|
MEDIA_ALLOWED_MIME_TYPES = {
|
|
"image/jpeg": "jpg",
|
|
"image/png": "png",
|
|
"image/webp": "webp",
|
|
"image/gif": "gif",
|
|
}
|
|
|
|
|
|
SITE_CONFIG_MODULES = {
|
|
"heroSlides": {
|
|
"model": HeroSlide,
|
|
"entity": "hero_slide",
|
|
"primary": "title",
|
|
"fields": {"title", "kicker", "image", "isActive", "sortOrder"},
|
|
"none_to_empty": {"image"},
|
|
"create_defaults": {"kicker": "", "image": ""},
|
|
},
|
|
"destinationHero": {
|
|
"model": DestinationHero,
|
|
"entity": "destination_hero",
|
|
"primary": "title",
|
|
"fields": {"title", "kicker", "image", "isActive", "sortOrder"},
|
|
"none_to_empty": set(),
|
|
"empty_to_none": {"kicker", "image"},
|
|
"create_defaults": {"kicker": None, "image": None},
|
|
},
|
|
"demandHero": {
|
|
"model": DemandHero,
|
|
"entity": "demand_hero",
|
|
"primary": "title",
|
|
"fields": {"title", "kicker", "description", "steps", "isActive", "sortOrder"},
|
|
"none_to_empty": set(),
|
|
"empty_to_none": {"kicker", "description"},
|
|
"create_defaults": {"kicker": None, "description": None, "steps": []},
|
|
},
|
|
"demandFeatureCards": {
|
|
"model": DemandFeatureCard,
|
|
"entity": "demand_feature_card",
|
|
"primary": "title",
|
|
"fields": {"title", "description", "isActive", "sortOrder"},
|
|
"none_to_empty": set(),
|
|
"empty_to_none": {"description"},
|
|
"create_defaults": {"description": None},
|
|
},
|
|
"demandForm": {
|
|
"model": DemandForm,
|
|
"entity": "demand_form",
|
|
"primary": "submitLabel",
|
|
"fields": {
|
|
"destinationLabel",
|
|
"destinationPlaceholder",
|
|
"phoneLabel",
|
|
"phonePlaceholder",
|
|
"noteLabel",
|
|
"notePlaceholder",
|
|
"submitLabel",
|
|
"chips",
|
|
"isActive",
|
|
},
|
|
"none_to_empty": set(),
|
|
"empty_to_none": {"destinationPlaceholder", "phonePlaceholder", "notePlaceholder"},
|
|
"create_defaults": {
|
|
"destinationLabel": "目的地/玩法",
|
|
"destinationPlaceholder": "例如：贵州、黄果树、西江苗寨",
|
|
"phoneLabel": "联系方式",
|
|
"phonePlaceholder": "手机号 / 微信号",
|
|
"noteLabel": "补充说明",
|
|
"notePlaceholder": "出行日期、人数、酒店偏好、预算范围",
|
|
"submitLabel": "提交出行需求",
|
|
"chips": ["贵州", "黄果树", "荔波小七孔", "西江苗寨", "梵净山", "万峰林"],
|
|
},
|
|
"ordered": False,
|
|
"singleton": True,
|
|
},
|
|
"vehicleOptions": {
|
|
"model": VehicleOption,
|
|
"entity": "vehicle_option",
|
|
"primary": "title",
|
|
"fields": {"title", "description", "image", "isActive", "sortOrder"},
|
|
"none_to_empty": set(),
|
|
"empty_to_none": {"description", "image"},
|
|
"create_defaults": {"description": None, "image": None},
|
|
},
|
|
}
|
|
|
|
def media_error(status_code: int, message: str, code: str, details: dict | None = None) -> None:
|
|
raise HTTPException(status_code=status_code, detail={"message": message, "code": code, "details": details or {}})
|
|
|
|
|
|
def normalize_media_group(group: str | None) -> str:
|
|
value = (group or "general").strip() or "general"
|
|
if len(value) > 32 or not re.fullmatch(r"[A-Za-z0-9_-]+", value):
|
|
media_error(400, "素材分组只能包含字母、数字、下划线和中划线", "MEDIA_UPLOAD_INVALID_GROUP", {"group": group})
|
|
return value
|
|
|
|
|
|
def safe_media_name(filename: str | None) -> str:
|
|
name = os.path.basename((filename or "upload").replace("\\", "/")).strip()
|
|
return name[:120] or "upload"
|
|
|
|
|
|
def detect_image_mime(head: bytes) -> str | None:
|
|
if head.startswith(b"\xff\xd8\xff"):
|
|
return "image/jpeg"
|
|
if head.startswith(b"\x89PNG\r\n\x1a\n"):
|
|
return "image/png"
|
|
if head.startswith((b"GIF87a", b"GIF89a")):
|
|
return "image/gif"
|
|
if len(head) >= 12 and head[:4] == b"RIFF" and head[8:12] == b"WEBP":
|
|
return "image/webp"
|
|
return None
|
|
|
|
|
|
def inspect_upload_image(file: UploadFile) -> tuple[str, int]:
|
|
content_type = (file.content_type or "").split(";", 1)[0].strip().lower()
|
|
if content_type == "image/jpg":
|
|
content_type = "image/jpeg"
|
|
if content_type and content_type not in MEDIA_ALLOWED_MIME_TYPES and content_type != "application/octet-stream":
|
|
media_error(400, "仅支持上传 JPG、PNG、WebP 或 GIF 图片", "MEDIA_UPLOAD_INVALID_TYPE", {"mimeType": content_type})
|
|
|
|
file.file.seek(0, os.SEEK_END)
|
|
size_bytes = file.file.tell()
|
|
file.file.seek(0)
|
|
if size_bytes <= 0:
|
|
media_error(400, "上传文件不能为空", "MEDIA_UPLOAD_EMPTY_FILE")
|
|
if size_bytes > MEDIA_UPLOAD_MAX_BYTES:
|
|
media_error(
|
|
413,
|
|
"图片大小不能超过 5MB",
|
|
"MEDIA_UPLOAD_TOO_LARGE",
|
|
{"maxBytes": MEDIA_UPLOAD_MAX_BYTES, "sizeBytes": size_bytes},
|
|
)
|
|
|
|
head = file.file.read(512)
|
|
file.file.seek(0)
|
|
detected = detect_image_mime(head)
|
|
if not detected:
|
|
media_error(400, "仅支持上传 JPG、PNG、WebP 或 GIF 图片", "MEDIA_UPLOAD_INVALID_TYPE")
|
|
if content_type in MEDIA_ALLOWED_MIME_TYPES and content_type != detected:
|
|
media_error(
|
|
400,
|
|
"图片内容与文件类型不一致",
|
|
"MEDIA_UPLOAD_TYPE_MISMATCH",
|
|
{"mimeType": content_type, "detectedMimeType": detected},
|
|
)
|
|
return detected, size_bytes
|
|
|
|
|
|
def media_object_key(group: str, mime_type: str) -> str:
|
|
extension = MEDIA_ALLOWED_MIME_TYPES[mime_type]
|
|
return f"admin/{group}/{utc_now().strftime('%Y/%m/%d')}/{uuid4().hex}.{extension}"
|
|
|
|
|
|
def oss_settings():
|
|
settings = get_settings()
|
|
values = {
|
|
"OSS_ACCESS_KEY_ID": settings.oss_access_key_id,
|
|
"OSS_ACCESS_KEY_SECRET": settings.oss_access_key_secret,
|
|
"OSS_ENDPOINT": settings.oss_endpoint,
|
|
"OSS_BUCKET_NAME": settings.oss_bucket_name,
|
|
}
|
|
missing = [key for key, value in values.items() if not (value and value.strip())]
|
|
if missing:
|
|
media_error(503, "OSS 存储配置不完整", "MEDIA_STORAGE_NOT_CONFIGURED", {"missing": missing})
|
|
return settings
|
|
|
|
|
|
def normalized_oss_host(endpoint: str, bucket: str) -> tuple[str, str]:
|
|
raw = endpoint.strip().rstrip("/")
|
|
if "://" not in raw:
|
|
raw = f"https://{raw}"
|
|
parsed = urlsplit(raw)
|
|
if parsed.scheme not in {"http", "https"} or not parsed.netloc:
|
|
media_error(503, "OSS Endpoint 配置不正确", "MEDIA_STORAGE_INVALID_ENDPOINT")
|
|
host = parsed.netloc
|
|
if not host.startswith(f"{bucket}."):
|
|
host = f"{bucket}.{host}"
|
|
return parsed.scheme, host
|
|
|
|
|
|
def upload_image_to_oss(file_obj, key: str, mime_type: str, size_bytes: int) -> str:
|
|
settings = oss_settings()
|
|
bucket = settings.oss_bucket_name.strip()
|
|
scheme, host = normalized_oss_host(settings.oss_endpoint, bucket)
|
|
date = formatdate(usegmt=True)
|
|
canonical_resource = f"/{bucket}/{key}"
|
|
string_to_sign = f"PUT\n\n{mime_type}\n{date}\n{canonical_resource}"
|
|
signature = base64.b64encode(
|
|
hmac.new(settings.oss_access_key_secret.strip().encode("utf-8"), string_to_sign.encode("utf-8"), hashlib.sha1).digest()
|
|
).decode("ascii")
|
|
quoted_key = quote(key, safe="/-_.~")
|
|
headers = {
|
|
"Authorization": f"OSS {settings.oss_access_key_id.strip()}:{signature}",
|
|
"Content-Type": mime_type,
|
|
"Content-Length": str(size_bytes),
|
|
"Date": date,
|
|
}
|
|
connection_class = http.client.HTTPSConnection if scheme == "https" else http.client.HTTPConnection
|
|
connection = connection_class(host, timeout=20)
|
|
try:
|
|
file_obj.seek(0)
|
|
connection.request("PUT", f"/{quoted_key}", body=file_obj, headers=headers)
|
|
response = connection.getresponse()
|
|
response.read(2048)
|
|
if response.status < 200 or response.status >= 300:
|
|
media_error(502, "OSS 上传失败", "MEDIA_STORAGE_UPLOAD_FAILED", {"status": response.status})
|
|
except OSError:
|
|
media_error(502, "OSS 上传失败", "MEDIA_STORAGE_UPLOAD_FAILED")
|
|
finally:
|
|
connection.close()
|
|
return urlunsplit((scheme, host, f"/{quoted_key}", "", ""))
|
|
|
|
|
|
def audit(db: Session, actor_id: str | None, action: str, entity: str, entity_id: str | None = None, after=None, before=None) -> None:
|
|
db.add(
|
|
AuditLog(
|
|
actorId=actor_id,
|
|
action=action,
|
|
entity=entity,
|
|
entityId=entity_id,
|
|
before=encode_value(before) if before is not None else None,
|
|
after=encode_value(after) if after is not None else None,
|
|
)
|
|
)
|
|
|
|
|
|
def site_config_error(status_code: int, message: str, code: str, details: dict | None = None) -> None:
|
|
raise HTTPException(status_code=status_code, detail={"message": message, "code": code, "details": details or {}})
|
|
|
|
|
|
def site_module(module: str) -> dict:
|
|
config = SITE_CONFIG_MODULES.get(module)
|
|
if not config:
|
|
site_config_error(400, "模块不存在或无权限操作", "MODULE_CONFIG_FORBIDDEN", {"module": module})
|
|
return config
|
|
|
|
|
|
def clean_site_value(value):
|
|
return value.strip() if isinstance(value, str) else value
|
|
|
|
|
|
def normalize_string_list(value) -> list[str]:
|
|
if value is None:
|
|
return []
|
|
return [item.strip() for item in value if isinstance(item, str) and item.strip()]
|
|
|
|
|
|
def site_field_value(config: dict, field: str, value):
|
|
if field in {"steps", "chips"}:
|
|
return normalize_string_list(value)
|
|
value = clean_site_value(value)
|
|
if value == "" and field in config.get("empty_to_none", set()):
|
|
return None
|
|
if value is None and field in config["none_to_empty"]:
|
|
return ""
|
|
return value
|
|
|
|
|
|
def validate_site_primary(config: dict, body: SiteConfigPatchIn) -> str:
|
|
primary = config["primary"]
|
|
value = clean_site_value(getattr(body, primary))
|
|
if not value:
|
|
site_config_error(422, "必填字段不能为空", "MODULE_CONFIG_VALIDATION_ERROR", {"field": primary})
|
|
return value
|
|
|
|
|
|
def next_site_sort_order(db: Session, model) -> int:
|
|
highest = db.scalar(select(func.max(model.sortOrder)))
|
|
return (highest + 1) if highest is not None else 0
|
|
|
|
|
|
def hero_slide_admin_dict(item: HeroSlide) -> dict:
|
|
return {
|
|
"id": item.id,
|
|
"title": item.title,
|
|
"kicker": item.kicker or None,
|
|
"image": item.image or None,
|
|
"isActive": item.isActive,
|
|
"sortOrder": item.sortOrder,
|
|
"createdAt": encode_value(item.createdAt),
|
|
"updatedAt": encode_value(item.updatedAt),
|
|
}
|
|
|
|
|
|
def site_item_dict(module: str, item) -> dict:
|
|
if module == "heroSlides":
|
|
return hero_slide_admin_dict(item)
|
|
return model_dict(item)
|
|
|
|
|
|
def module_items(db: Session, config: dict) -> list:
|
|
model = config["model"]
|
|
stmt = select(model)
|
|
if config.get("ordered", True):
|
|
stmt = stmt.order_by(model.sortOrder.asc())
|
|
else:
|
|
stmt = stmt.order_by(model.createdAt.asc())
|
|
return db.scalars(stmt).all()
|
|
|
|
|
|
def normalize_site_sort_orders(items: list) -> None:
|
|
for index, item in enumerate(items):
|
|
item.sortOrder = index
|
|
|
|
|
|
def site_create_payload(module: str, config: dict, body: SiteConfigPatchIn, db: Session) -> dict:
|
|
fields = body.model_fields_set
|
|
payload = {
|
|
field: site_field_value(config, field, getattr(body, field))
|
|
for field in config["fields"]
|
|
if field in fields
|
|
}
|
|
payload[config["primary"]] = validate_site_primary(config, body)
|
|
for field, value in config["create_defaults"].items():
|
|
payload.setdefault(field, value)
|
|
if "isActive" in config["fields"]:
|
|
payload["isActive"] = payload.get("isActive", True)
|
|
if config.get("ordered", True) and payload.get("sortOrder") is None:
|
|
payload["sortOrder"] = next_site_sort_order(db, config["model"])
|
|
return payload
|
|
|
|
|
|
def apply_site_patch(module: str, config: dict, item, body: SiteConfigPatchIn) -> None:
|
|
fields = body.model_fields_set
|
|
for field in config["fields"]:
|
|
if field not in fields:
|
|
continue
|
|
value = site_field_value(config, field, getattr(body, field))
|
|
if field == config["primary"] and not value:
|
|
site_config_error(422, "必填字段不能为空", "MODULE_CONFIG_VALIDATION_ERROR", {"field": field})
|
|
setattr(item, field, value)
|
|
|
|
|
|
@router.post("/auth/login")
|
|
def login(body: LoginIn, db: Session = Depends(get_db)):
|
|
user = db.scalar(select(AdminUser).where(AdminUser.email == body.email))
|
|
if not user or not user.isActive or not verify_password(body.password, user.passwordHash):
|
|
raise HTTPException(status_code=401, detail="账号或密码错误")
|
|
return {
|
|
"token": create_token(user),
|
|
"user": {"id": user.id, "email": user.email, "name": user.name, "role": user.role},
|
|
}
|
|
|
|
|
|
@router.get("/me")
|
|
def me(user: AdminUser = Depends(require_admin)):
|
|
return {"id": user.id, "email": user.email, "name": user.name, "role": user.role}
|
|
|
|
|
|
@router.get("/dashboard")
|
|
def dashboard(_user: AdminUser = Depends(require_admin), db: Session = Depends(get_db)):
|
|
stats = {
|
|
"newLeadCount": db.scalar(select(func.count()).select_from(Lead).where(Lead.status == "new")),
|
|
"leadCount": db.scalar(select(func.count()).select_from(Lead)),
|
|
}
|
|
recent = db.scalars(
|
|
select(Lead).options(selectinload(Lead.assignedUser)).order_by(Lead.createdAt.desc()).limit(5)
|
|
).all()
|
|
return {"stats": stats, "recentLeads": [lead_dict(lead) for lead in recent]}
|
|
|
|
|
|
@router.get("/site-config")
|
|
def admin_site_config(_user: AdminUser = Depends(require_admin), db: Session = Depends(get_db)):
|
|
return {
|
|
"heroSlides": [
|
|
hero_slide_admin_dict(item)
|
|
for item in db.scalars(select(HeroSlide).order_by(HeroSlide.sortOrder.asc())).all()
|
|
],
|
|
"destinationHero": [
|
|
model_dict(item)
|
|
for item in db.scalars(select(DestinationHero).order_by(DestinationHero.sortOrder.asc())).all()
|
|
],
|
|
"vehicleOptions": [
|
|
model_dict(item)
|
|
for item in db.scalars(select(VehicleOption).order_by(VehicleOption.sortOrder.asc())).all()
|
|
],
|
|
"demandHero": [
|
|
model_dict(item)
|
|
for item in db.scalars(select(DemandHero).order_by(DemandHero.sortOrder.asc())).all()
|
|
],
|
|
"demandFeatureCards": [
|
|
model_dict(item)
|
|
for item in db.scalars(select(DemandFeatureCard).order_by(DemandFeatureCard.sortOrder.asc())).all()
|
|
],
|
|
"demandForm": [
|
|
model_dict(item)
|
|
for item in db.scalars(select(DemandForm).order_by(DemandForm.createdAt.asc())).all()
|
|
],
|
|
}
|
|
|
|
|
|
@router.post("/site-config/{module}", status_code=status.HTTP_201_CREATED)
|
|
def create_site_config(
|
|
module: str,
|
|
body: SiteConfigPatchIn,
|
|
request: Request,
|
|
_user: AdminUser = Depends(require_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
config = site_module(module)
|
|
if config.get("fixed"):
|
|
site_config_error(405, "固定模块不支持新增", "MODULE_CONFIG_CREATE_UNSUPPORTED", {"module": module})
|
|
if config.get("singleton") and module_items(db, config):
|
|
site_config_error(409, "单例配置已存在", "MODULE_CONFIG_SINGLETON_EXISTS", {"module": module})
|
|
item = config["model"](**site_create_payload(module, config, body, db))
|
|
db.add(item)
|
|
db.flush()
|
|
after = site_item_dict(module, item)
|
|
audit(db, get_actor_id(request), "create", config["entity"], item.id, after)
|
|
db.commit()
|
|
return after
|
|
|
|
|
|
@router.patch("/site-config/{module}/reorder")
|
|
def reorder_site_config(
|
|
module: str,
|
|
body: SiteConfigReorderIn,
|
|
request: Request,
|
|
_user: AdminUser = Depends(require_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
config = site_module(module)
|
|
if not config.get("ordered", True):
|
|
site_config_error(400, "模块不支持排序", "MODULE_CONFIG_REORDER_UNSUPPORTED", {"module": module})
|
|
items = module_items(db, config)
|
|
current_ids = [item.id for item in items]
|
|
requested_ids = body.itemIds
|
|
if len(set(requested_ids)) != len(requested_ids) or set(requested_ids) != set(current_ids):
|
|
site_config_error(
|
|
400,
|
|
"排序配置项必须完整且不能重复",
|
|
"MODULE_CONFIG_REORDER_INVALID",
|
|
{"module": module, "itemIds": requested_ids},
|
|
)
|
|
items_by_id = {item.id: item for item in items}
|
|
ordered_items = [items_by_id[item_id] for item_id in requested_ids]
|
|
before = [site_item_dict(module, item) for item in items]
|
|
normalize_site_sort_orders(ordered_items)
|
|
after = [site_item_dict(module, item) for item in ordered_items]
|
|
audit(db, get_actor_id(request), "reorder", config["entity"], module, {"items": after}, {"items": before})
|
|
db.commit()
|
|
return {"items": after}
|
|
|
|
|
|
@router.patch("/site-config/{module}/{item_id}")
|
|
def update_site_config(
|
|
module: str,
|
|
item_id: str,
|
|
body: SiteConfigPatchIn,
|
|
request: Request,
|
|
_user: AdminUser = Depends(require_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
config = site_module(module)
|
|
item = db.get(config["model"], item_id)
|
|
if not item:
|
|
site_config_error(404, "维护项不存在", "MODULE_CONFIG_NOT_FOUND", {"module": module, "id": item_id})
|
|
before = site_item_dict(module, item)
|
|
apply_site_patch(module, config, item, body)
|
|
db.flush()
|
|
after = site_item_dict(module, item)
|
|
audit(db, get_actor_id(request), "update", config["entity"], item.id, after, before)
|
|
db.commit()
|
|
return after
|
|
|
|
|
|
@router.delete("/site-config/{module}/{item_id}")
|
|
def delete_site_config(
|
|
module: str,
|
|
item_id: str,
|
|
request: Request,
|
|
_user: AdminUser = Depends(require_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
config = site_module(module)
|
|
if config.get("fixed"):
|
|
site_config_error(405, "固定模块不支持删除", "MODULE_CONFIG_DELETE_UNSUPPORTED", {"module": module})
|
|
item = db.get(config["model"], item_id)
|
|
if not item:
|
|
site_config_error(404, "维护项不存在", "MODULE_CONFIG_NOT_FOUND", {"module": module, "id": item_id})
|
|
before = site_item_dict(module, item)
|
|
db.delete(item)
|
|
db.flush()
|
|
if config.get("ordered", True):
|
|
normalize_site_sort_orders(module_items(db, config))
|
|
result = {"id": item_id}
|
|
audit(db, get_actor_id(request), "delete", config["entity"], item_id, result, before)
|
|
db.commit()
|
|
return result
|
|
|
|
|
|
@router.get("/leads")
|
|
def list_leads(
|
|
status_value: LeadStatus | None = Query(default=None, alias="status"),
|
|
sourcePage: str | None = None,
|
|
keyword: str | None = None,
|
|
createdFrom: str | None = None,
|
|
createdTo: str | None = None,
|
|
take: int = Query(default=100, ge=1, le=200),
|
|
_user: AdminUser = Depends(require_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
query = LeadQuery(
|
|
status=status_value,
|
|
sourcePage=sourcePage,
|
|
keyword=keyword,
|
|
createdFrom=createdFrom,
|
|
createdTo=createdTo,
|
|
take=take,
|
|
)
|
|
stmt = (
|
|
select(Lead)
|
|
.options(selectinload(Lead.assignedUser))
|
|
.order_by(Lead.createdAt.desc())
|
|
.limit(query.take)
|
|
)
|
|
if query.status:
|
|
stmt = stmt.where(Lead.status == query.status)
|
|
if query.sourcePage:
|
|
stmt = stmt.where(Lead.sourcePage == query.sourcePage.strip())
|
|
if query.createdFrom:
|
|
stmt = stmt.where(Lead.createdAt >= query.createdFrom)
|
|
if query.createdTo:
|
|
stmt = stmt.where(Lead.createdAt < query.createdTo)
|
|
if query.keyword and query.keyword.strip():
|
|
pattern = f"%{query.keyword.strip()}%"
|
|
stmt = stmt.where(
|
|
or_(
|
|
Lead.phone.ilike(pattern),
|
|
Lead.destination.ilike(pattern),
|
|
Lead.note.ilike(pattern),
|
|
)
|
|
).distinct()
|
|
leads = db.scalars(stmt).all()
|
|
return {"items": [lead_dict(lead) for lead in leads]}
|
|
|
|
|
|
@router.patch("/leads/{lead_id}/status")
|
|
def update_lead_status(lead_id: str, body: LeadStatusIn, request: Request, _user: AdminUser = Depends(require_admin), db: Session = Depends(get_db)):
|
|
lead = db.get(Lead, lead_id)
|
|
if not lead:
|
|
raise HTTPException(status_code=404, detail="线索不存在")
|
|
before = model_dict(lead)
|
|
lead.status = body.status
|
|
db.flush()
|
|
audit(db, get_actor_id(request), "update_status", "lead", lead.id, model_dict(lead), before)
|
|
db.commit()
|
|
return model_dict(lead)
|
|
|
|
|
|
@router.get("/media-assets")
|
|
def list_media_assets(_user: AdminUser = Depends(require_admin), db: Session = Depends(get_db)):
|
|
assets = db.scalars(select(MediaAsset).order_by(MediaAsset.createdAt.desc()).limit(200)).all()
|
|
return {"items": [model_dict(asset) for asset in assets]}
|
|
|
|
|
|
@router.post("/media-assets/upload", status_code=status.HTTP_201_CREATED)
|
|
def upload_media_asset(
|
|
request: Request,
|
|
file: UploadFile = File(...),
|
|
group: str | None = Form(default="general"),
|
|
_user: AdminUser = Depends(require_admin),
|
|
db: Session = Depends(get_db),
|
|
):
|
|
safe_group = normalize_media_group(group)
|
|
mime_type, size_bytes = inspect_upload_image(file)
|
|
key = media_object_key(safe_group, mime_type)
|
|
url = upload_image_to_oss(file.file, key, mime_type, size_bytes)
|
|
asset = MediaAsset(
|
|
url=url,
|
|
name=safe_media_name(file.filename),
|
|
mimeType=mime_type,
|
|
sizeBytes=size_bytes,
|
|
group=safe_group,
|
|
)
|
|
db.add(asset)
|
|
db.flush()
|
|
after = model_dict(asset)
|
|
audit(db, get_actor_id(request), "upload", "media_asset", asset.id, after)
|
|
db.commit()
|
|
return after
|
|
|
|
|
|
@router.post("/reset-guizhou-content")
|
|
def reset_content(request: Request, _user: AdminUser = Depends(require_admin), db: Session = Depends(get_db)):
|
|
result = reset_guizhou_content(db)
|
|
audit(db, get_actor_id(request), "reset_guizhou_content", "site_content", after=result)
|
|
db.commit()
|
|
return result
|
|
|
|
|
|
@router.post("/publish", status_code=status.HTTP_201_CREATED)
|
|
def publish(request: Request, _user: AdminUser = Depends(require_admin), db: Session = Depends(get_db)):
|
|
snapshot = site_config(db, active_only=True)
|
|
version = SiteVersion(title=f"manual-{utc_now().isoformat()}", status="published", snapshot=snapshot, publishedAt=utc_now())
|
|
db.add(version)
|
|
db.flush()
|
|
audit(db, get_actor_id(request), "publish", "site_version", version.id, model_dict(version))
|
|
db.commit()
|
|
return model_dict(version)
|