1187 lines
53 KiB
Python
1187 lines
53 KiB
Python
"""PPT/海报管理后台服务。"""
|
||
import hashlib
|
||
import json
|
||
import logging
|
||
import os
|
||
import uuid
|
||
from insurance.db.compat import db
|
||
from insurance.models.ppt_config import PptCompany, PptProduct, PptScenario, PptTemplate
|
||
from insurance.models.ppt_history import PptHistory
|
||
from insurance.models.poster_template_model import PosterTemplate
|
||
from insurance.models.poster_copy_template import PosterCopyTemplate
|
||
from insurance.models.poster_record import PosterRecord
|
||
from insurance.models.system_setting import SystemSetting
|
||
from sqlalchemy import or_
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
def _storage_key(value: str) -> str:
|
||
"""将外部 ID 转为安全、稳定的存储目录名。"""
|
||
return hashlib.sha256(value.encode("utf-8")).hexdigest()[:32]
|
||
|
||
|
||
def _safe_page_params(params: dict) -> tuple[int, int]:
|
||
"""安全获取分页参数，防止负数和超大值。"""
|
||
page = max(1, params.get("page", 1))
|
||
page_size = min(100, max(1, params.get("page_size", 20)))
|
||
return page, page_size
|
||
|
||
|
||
def _poster_compatibility_error(modes, formats) -> str | None:
|
||
if not isinstance(modes, list) or not modes or not set(modes).issubset({"single", "long"}):
|
||
return "supportedModes 不合法"
|
||
from insurance.poster.format_registry import list_poster_formats
|
||
specs = {item["id"]: item for item in list_poster_formats()}
|
||
if not isinstance(formats, list) or not formats or not set(formats).issubset(specs):
|
||
return "supportedFormats 不合法"
|
||
incompatible = [item for item in formats if specs[item]["outputMode"] not in modes]
|
||
if incompatible:
|
||
return f"格式与兼容模式不一致: {', '.join(incompatible)}"
|
||
return None
|
||
|
||
|
||
class PptAdminService:
|
||
"""PPT/海报管理后台业务逻辑。"""
|
||
|
||
# ---- 保司管理 ----
|
||
|
||
def list_companies(self, params: dict) -> dict:
|
||
query = db.session.query(PptCompany).filter(PptCompany.deleted_at.is_(None))
|
||
if params.get("status") is not None:
|
||
query = query.filter(PptCompany.status == params["status"])
|
||
if params.get("keyword"):
|
||
kw = f"%{params['keyword']}%"
|
||
query = query.filter(or_(
|
||
PptCompany.display_name.ilike(kw),
|
||
PptCompany.name_zh.ilike(kw),
|
||
PptCompany.name_en.ilike(kw),
|
||
))
|
||
query = query.order_by(PptCompany.sort_order.asc(), PptCompany.id.asc())
|
||
page, page_size = _safe_page_params(params)
|
||
total = query.count()
|
||
items = query.offset((page - 1) * page_size).limit(page_size).all()
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"total": total,
|
||
"items": [c.to_dict() for c in items],
|
||
},
|
||
}
|
||
|
||
def create_company(self, data: dict) -> dict:
|
||
if not data.get("id") or not data.get("displayName"):
|
||
return {"code": 1001, "message": "id 和 displayName 必填", "data": None}
|
||
if data.get("maskingEnabled") and not data.get("maskedDisplayName"):
|
||
return {"code": 1001, "message": "开启名称脱敏前请填写脱敏展示名", "data": None}
|
||
if PptCompany.query.get(data["id"]):
|
||
return {"code": 1001, "message": "公司 ID 已存在", "data": None}
|
||
company = PptCompany(
|
||
id=data["id"],
|
||
display_name=data["displayName"],
|
||
aliases_json=json.dumps(data.get("aliases", []), ensure_ascii=False),
|
||
name_zh=data.get("nameZh"),
|
||
name_en=data.get("nameEn"),
|
||
short_en=data.get("shortEn"),
|
||
logo_url=data.get("logoUrl"),
|
||
company_intro=data.get("companyIntro"),
|
||
masked_display_name=data.get("maskedDisplayName"),
|
||
masking_enabled=bool(data.get("maskingEnabled", False)),
|
||
logo_enabled=bool(data.get("logoEnabled", True)),
|
||
status=data.get("status", 1),
|
||
sort_order=data.get("sortOrder", 0),
|
||
)
|
||
db.session.add(company)
|
||
db.session.commit()
|
||
return {"code": 0, "data": company.to_dict()}
|
||
|
||
def update_company(self, company_id: str, data: dict, user_id: str = "system") -> dict:
|
||
company = PptCompany.query.get(company_id)
|
||
if not company or company.deleted_at:
|
||
return {"code": 1002, "message": "公司不存在", "data": None}
|
||
old_value = company.to_dict()
|
||
next_masked_name = (
|
||
data.get("maskedDisplayName")
|
||
if "maskedDisplayName" in data
|
||
else company.masked_display_name
|
||
)
|
||
next_masking_enabled = (
|
||
bool(data.get("maskingEnabled"))
|
||
if "maskingEnabled" in data
|
||
else bool(company.masking_enabled)
|
||
)
|
||
if next_masking_enabled and not next_masked_name:
|
||
return {"code": 1001, "message": "开启名称脱敏前请填写脱敏展示名", "data": None}
|
||
if "displayName" in data:
|
||
company.display_name = data["displayName"]
|
||
if "aliases" in data:
|
||
company.aliases_json = json.dumps(data["aliases"], ensure_ascii=False)
|
||
if "nameZh" in data:
|
||
company.name_zh = data["nameZh"]
|
||
if "nameEn" in data:
|
||
company.name_en = data["nameEn"]
|
||
if "shortEn" in data:
|
||
company.short_en = data["shortEn"]
|
||
if "logoUrl" in data:
|
||
company.logo_url = data["logoUrl"]
|
||
if "companyIntro" in data:
|
||
company.company_intro = data["companyIntro"]
|
||
if "maskedDisplayName" in data:
|
||
company.masked_display_name = data["maskedDisplayName"] or None
|
||
if "maskingEnabled" in data:
|
||
company.masking_enabled = bool(data["maskingEnabled"])
|
||
if "logoEnabled" in data:
|
||
company.logo_enabled = bool(data["logoEnabled"])
|
||
if "status" in data:
|
||
company.status = data["status"]
|
||
if "sortOrder" in data:
|
||
company.sort_order = data["sortOrder"]
|
||
db.session.commit()
|
||
from insurance.utils.audit import log_config_change
|
||
log_config_change(user_id, "ppt_company", company_id, old_value, company.to_dict())
|
||
return {"code": 0, "data": company.to_dict()}
|
||
|
||
def update_company_status(self, company_id: str, data: dict) -> dict:
|
||
company = PptCompany.query.get(company_id)
|
||
if not company or company.deleted_at:
|
||
return {"code": 1002, "message": "公司不存在", "data": None}
|
||
company.status = data.get("status", 1)
|
||
db.session.commit()
|
||
return {"code": 0, "data": company.to_dict()}
|
||
|
||
def delete_company(self, company_id: str, user_id: str = "system") -> dict:
|
||
company = PptCompany.query.filter_by(id=company_id, deleted_at=None).first()
|
||
if not company:
|
||
return {"code": 1002, "message": "公司不存在", "data": None}
|
||
active_products = PptProduct.query.filter_by(
|
||
company_id=company_id, status=1, deleted_at=None
|
||
).count()
|
||
if active_products:
|
||
return {
|
||
"code": 1003,
|
||
"message": f"该保司仍有 {active_products} 个启用产品，请先停用或删除产品",
|
||
"data": {"activeProductCount": active_products},
|
||
}
|
||
from datetime import datetime
|
||
company.status = 0
|
||
company.deleted_at = datetime.now()
|
||
db.session.commit()
|
||
from insurance.utils.audit import log_operation
|
||
log_operation(user_id, "delete", "ppt_company", company_id, {"softDelete": True})
|
||
return {"code": 0, "data": None}
|
||
|
||
# ---- 保司Logo管理 ----
|
||
|
||
# 允许的图片类型和大小限制
|
||
_ALLOWED_LOGO_TYPES = {"image/png", "image/jpeg", "image/webp"}
|
||
_MAX_LOGO_SIZE = 5 * 1024 * 1024 # 5MB
|
||
_MAX_LOGOS_PER_COMPANY = 10
|
||
|
||
def list_company_logos(self, company_id: str) -> dict:
|
||
from insurance.models.ppt_config import CompanyLogo
|
||
logos = CompanyLogo.query.filter_by(company_id=company_id)\
|
||
.order_by(CompanyLogo.sort_order.asc(), CompanyLogo.id.asc()).all()
|
||
return {"code": 0, "data": [logo.to_dict() for logo in logos]}
|
||
|
||
def upload_company_logos(self, company_id: str, files: list) -> dict:
|
||
"""上传多张保司Logo图片。"""
|
||
from insurance.models.ppt_config import CompanyLogo
|
||
company = PptCompany.query.get(company_id)
|
||
if not company:
|
||
return {"code": 1002, "message": "公司不存在", "data": None}
|
||
|
||
# 检查数量限制
|
||
existing_count = CompanyLogo.query.filter_by(company_id=company_id).count()
|
||
if existing_count + len(files) > self._MAX_LOGOS_PER_COMPANY:
|
||
return {
|
||
"code": 1003,
|
||
"message": f"最多上传 {self._MAX_LOGOS_PER_COMPANY} 张Logo，当前已有 {existing_count} 张",
|
||
"data": None,
|
||
}
|
||
|
||
from insurance.config import get_storage_root
|
||
upload_dir = os.path.join(
|
||
get_storage_root(), "uploads", "company-logos", _storage_key(company_id)
|
||
)
|
||
os.makedirs(upload_dir, exist_ok=True)
|
||
|
||
uploaded = []
|
||
errors = []
|
||
for file in files:
|
||
if not file.filename:
|
||
continue
|
||
# 校验类型
|
||
if file.content_type not in self._ALLOWED_LOGO_TYPES:
|
||
errors.append(f"{file.filename}: 仅支持 PNG/JPEG/WebP 格式")
|
||
continue
|
||
# 校验大小
|
||
file.seek(0, os.SEEK_END)
|
||
size = file.tell()
|
||
file.seek(0)
|
||
if size == 0:
|
||
errors.append(f"{file.filename}: 文件为空")
|
||
continue
|
||
if size > self._MAX_LOGO_SIZE:
|
||
errors.append(f"{file.filename}: 文件大小超过 5MB 限制")
|
||
continue
|
||
|
||
# 用 Pillow 验证并重编码（去除 EXIF）
|
||
try:
|
||
from PIL import Image
|
||
img = Image.open(file.stream)
|
||
detected_format = (img.format or "").upper()
|
||
if detected_format not in ("PNG", "JPEG", "WEBP"):
|
||
raise ValueError("图片实际格式不受支持")
|
||
img.verify()
|
||
file.seek(0)
|
||
img = Image.open(file.stream)
|
||
img.load()
|
||
# JPEG 不支持透明通道；PNG/WebP 保留透明背景。
|
||
if detected_format == "JPEG" and img.mode != "RGB":
|
||
img = img.convert("RGB")
|
||
elif detected_format in ("PNG", "WEBP") and img.mode not in ("RGB", "RGBA"):
|
||
img = img.convert("RGBA")
|
||
save_format = detected_format
|
||
mime = f"image/{save_format.lower()}"
|
||
except Exception as e:
|
||
errors.append(f"{file.filename}: 图片文件损坏 ({e})")
|
||
continue
|
||
|
||
# 保存文件
|
||
logo_id = uuid.uuid4().hex
|
||
extension = "jpg" if save_format == "JPEG" else save_format.lower()
|
||
filename = f"{logo_id}.{extension}"
|
||
filepath = os.path.join(upload_dir, filename)
|
||
img.save(filepath, format=save_format, quality=90)
|
||
|
||
# 创建记录
|
||
logo = CompanyLogo(
|
||
id=logo_id,
|
||
company_id=company_id,
|
||
file_path=filepath,
|
||
file_url=f"/insurance/admin/ppt/assets/company-logos/{logo_id}",
|
||
original_name=file.filename,
|
||
mime_type=mime,
|
||
file_size=os.path.getsize(filepath),
|
||
is_primary=(existing_count == 0 and len(uploaded) == 0), # 第一张自动设为主图
|
||
sort_order=existing_count + len(uploaded),
|
||
)
|
||
db.session.add(logo)
|
||
uploaded.append(logo)
|
||
|
||
if uploaded:
|
||
db.session.commit()
|
||
# 同步主图到 company.logo_url
|
||
primary = next((l for l in uploaded if l.is_primary), None)
|
||
if primary:
|
||
company.logo_url = primary.file_url
|
||
db.session.commit()
|
||
|
||
result = {"uploaded": [l.to_dict() for l in uploaded]}
|
||
if errors:
|
||
result["errors"] = errors
|
||
return {"code": 0, "data": result}
|
||
|
||
def set_primary_logo(self, company_id: str, logo_id: str) -> dict:
|
||
"""设置指定Logo为主图。"""
|
||
from insurance.models.ppt_config import CompanyLogo
|
||
logo = CompanyLogo.query.get(logo_id)
|
||
if not logo or logo.company_id != company_id:
|
||
return {"code": 1002, "message": "Logo不存在", "data": None}
|
||
|
||
# 取消当前主图
|
||
CompanyLogo.query.filter_by(company_id=company_id, is_primary=True)\
|
||
.update({"is_primary": False})
|
||
logo.is_primary = True
|
||
|
||
# 同步到 company.logo_url
|
||
company = PptCompany.query.get(company_id)
|
||
if company:
|
||
company.logo_url = logo.file_url
|
||
db.session.commit()
|
||
return {"code": 0, "data": logo.to_dict()}
|
||
|
||
def reorder_logos(self, company_id: str, order_data: list) -> dict:
|
||
"""重排Logo顺序。order_data = [{"id": "xxx", "sortOrder": 0}, ...]"""
|
||
from insurance.models.ppt_config import CompanyLogo
|
||
for item in order_data:
|
||
logo = CompanyLogo.query.get(item.get("id"))
|
||
if logo and logo.company_id == company_id:
|
||
logo.sort_order = item.get("sortOrder", 0)
|
||
db.session.commit()
|
||
return {"code": 0, "data": None}
|
||
|
||
def delete_company_logo(self, company_id: str, logo_id: str) -> dict:
|
||
"""删除指定Logo。"""
|
||
from insurance.models.ppt_config import CompanyLogo
|
||
logo = CompanyLogo.query.get(logo_id)
|
||
if not logo or logo.company_id != company_id:
|
||
return {"code": 1002, "message": "Logo不存在", "data": None}
|
||
|
||
was_primary = logo.is_primary
|
||
# 删除文件
|
||
if logo.file_path and os.path.exists(logo.file_path):
|
||
try:
|
||
os.remove(logo.file_path)
|
||
except Exception as e:
|
||
logger.warning(f"删除Logo文件失败: {e}")
|
||
|
||
db.session.delete(logo)
|
||
db.session.commit()
|
||
|
||
# 如果删除的是主图，自动将下一张设为主图
|
||
if was_primary:
|
||
next_primary = CompanyLogo.query.filter_by(company_id=company_id)\
|
||
.order_by(CompanyLogo.sort_order.asc()).first()
|
||
if next_primary:
|
||
next_primary.is_primary = True
|
||
company = PptCompany.query.get(company_id)
|
||
if company:
|
||
company.logo_url = next_primary.file_url
|
||
else:
|
||
company = PptCompany.query.get(company_id)
|
||
if company:
|
||
company.logo_url = None
|
||
db.session.commit()
|
||
|
||
return {"code": 0, "data": None}
|
||
|
||
# ---- 产品管理 ----
|
||
|
||
def list_products(self, params: dict) -> dict:
|
||
query = db.session.query(PptProduct).filter(PptProduct.deleted_at.is_(None))
|
||
if params.get("company_id"):
|
||
query = query.filter(PptProduct.company_id == params["company_id"])
|
||
if params.get("plan_type"):
|
||
query = query.filter(PptProduct.plan_type == params["plan_type"])
|
||
if params.get("status") is not None:
|
||
query = query.filter(PptProduct.status == params["status"])
|
||
query = query.order_by(PptProduct.sort_order.asc(), PptProduct.id.asc())
|
||
page, page_size = _safe_page_params(params)
|
||
total = query.count()
|
||
items = query.offset((page - 1) * page_size).limit(page_size).all()
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"total": total,
|
||
"items": [p.to_dict() for p in items],
|
||
},
|
||
}
|
||
|
||
def create_product(self, data: dict) -> dict:
|
||
if not data.get("id") or not data.get("displayName"):
|
||
return {"code": 1001, "message": "id 和 displayName 必填", "data": None}
|
||
if data.get("maskingEnabled") and not data.get("maskedDisplayName"):
|
||
return {"code": 1001, "message": "开启名称脱敏前请填写脱敏展示名", "data": None}
|
||
if PptProduct.query.get(data["id"]):
|
||
return {"code": 1001, "message": "产品 ID 已存在", "data": None}
|
||
product = PptProduct(
|
||
id=data["id"],
|
||
company_id=data.get("companyId", ""),
|
||
plan_type=data.get("planType", "savings"),
|
||
display_name=data["displayName"],
|
||
aliases_json=json.dumps(data.get("aliases", []), ensure_ascii=False),
|
||
required_modules_json=json.dumps(data.get("requiredModules", []), ensure_ascii=False),
|
||
masked_display_name=data.get("maskedDisplayName"),
|
||
masking_enabled=bool(data.get("maskingEnabled", False)),
|
||
product_code=data.get("productCode"),
|
||
product_type=data.get("productType"),
|
||
coverage_period=data.get("coveragePeriod"),
|
||
payment_period=data.get("paymentPeriod"),
|
||
insured_age_range=data.get("insuredAgeRange"),
|
||
waiting_period=data.get("waitingPeriod"),
|
||
highlights=json.dumps(data.get("highlights", []), ensure_ascii=False) if data.get("highlights") else None,
|
||
extra_fields=json.dumps(data.get("extraFields", {}), ensure_ascii=False) if data.get("extraFields") else None,
|
||
status=data.get("status", 1),
|
||
sort_order=data.get("sortOrder", 0),
|
||
)
|
||
db.session.add(product)
|
||
db.session.commit()
|
||
return {"code": 0, "data": product.to_dict()}
|
||
|
||
def update_product(self, product_id: str, data: dict, user_id: str = "system") -> dict:
|
||
product = PptProduct.query.get(product_id)
|
||
if not product or product.deleted_at:
|
||
return {"code": 1002, "message": "产品不存在", "data": None}
|
||
old_value = product.to_dict()
|
||
next_masked_name = (
|
||
data.get("maskedDisplayName")
|
||
if "maskedDisplayName" in data
|
||
else product.masked_display_name
|
||
)
|
||
next_masking_enabled = (
|
||
bool(data.get("maskingEnabled"))
|
||
if "maskingEnabled" in data
|
||
else bool(product.masking_enabled)
|
||
)
|
||
if next_masking_enabled and not next_masked_name:
|
||
return {"code": 1001, "message": "开启名称脱敏前请填写脱敏展示名", "data": None}
|
||
simple_fields = {
|
||
"displayName": "display_name", "companyId": "company_id",
|
||
"planType": "plan_type", "productCode": "product_code",
|
||
"productType": "product_type", "coveragePeriod": "coverage_period",
|
||
"paymentPeriod": "payment_period", "insuredAgeRange": "insured_age_range",
|
||
"waitingPeriod": "waiting_period", "status": "status", "sortOrder": "sort_order",
|
||
"maskedDisplayName": "masked_display_name",
|
||
"maskingEnabled": "masking_enabled",
|
||
}
|
||
for key, attr in simple_fields.items():
|
||
if key in data:
|
||
setattr(product, attr, data[key])
|
||
json_fields = {
|
||
"aliases": "aliases_json", "requiredModules": "required_modules_json",
|
||
"highlights": "highlights", "extraFields": "extra_fields",
|
||
}
|
||
for key, attr in json_fields.items():
|
||
if key in data:
|
||
setattr(product, attr, json.dumps(data[key], ensure_ascii=False) if data[key] else None)
|
||
db.session.commit()
|
||
from insurance.utils.audit import log_config_change
|
||
log_config_change(user_id, "ppt_product", product_id, old_value, product.to_dict())
|
||
return {"code": 0, "data": product.to_dict()}
|
||
|
||
def update_product_status(self, product_id: str, data: dict) -> dict:
|
||
product = PptProduct.query.get(product_id)
|
||
if not product or product.deleted_at:
|
||
return {"code": 1002, "message": "产品不存在", "data": None}
|
||
product.status = data.get("status", 1)
|
||
db.session.commit()
|
||
return {"code": 0, "data": product.to_dict()}
|
||
|
||
def delete_product(self, product_id: str, user_id: str = "system") -> dict:
|
||
product = PptProduct.query.filter_by(id=product_id, deleted_at=None).first()
|
||
if not product:
|
||
return {"code": 1002, "message": "产品不存在", "data": None}
|
||
from datetime import datetime
|
||
product.status = 0
|
||
product.deleted_at = datetime.now()
|
||
db.session.commit()
|
||
from insurance.utils.audit import log_operation
|
||
log_operation(user_id, "delete", "ppt_product", product_id, {"softDelete": True})
|
||
return {"code": 0, "data": None}
|
||
|
||
# ---- 产品小册子 ----
|
||
|
||
def upload_manual(self, product_id: str, file, password: str = "") -> dict:
|
||
product = PptProduct.query.get(product_id)
|
||
if not product:
|
||
return {"code": 1002, "message": "产品不存在", "data": None}
|
||
if not file.filename or not file.filename.lower().endswith(".pdf"):
|
||
return {"code": 1003, "message": "仅支持 PDF 文件", "data": None}
|
||
|
||
# 校验 PDF；加密文件使用用户本次提供的密码生成解密副本。
|
||
from insurance.utils.security import prepare_pdf_upload
|
||
is_valid, err_msg, pdf_bytes = prepare_pdf_upload(file, password)
|
||
if not is_valid:
|
||
code = 4003 if "密码" in err_msg else 1003
|
||
return {"code": code, "message": err_msg, "data": None}
|
||
|
||
# 使用持久化存储目录
|
||
from insurance.config import get_storage_root
|
||
upload_dir = os.path.join(
|
||
get_storage_root(), "uploads", "product-manuals", _storage_key(product_id)
|
||
)
|
||
os.makedirs(upload_dir, exist_ok=True)
|
||
filename = f"{uuid.uuid4().hex}.pdf"
|
||
filepath = os.path.join(upload_dir, filename)
|
||
with open(filepath, "wb") as output:
|
||
output.write(pdf_bytes)
|
||
|
||
# 更新产品记录
|
||
product.manual_file_url = filepath
|
||
product.manual_parse_status = "pending"
|
||
# 清空旧解析结果和错误信息
|
||
product.manual_parsed_rules = None
|
||
product.manual_parse_error = None
|
||
product.manual_parse_message = ""
|
||
product.manual_parse_task_id = None
|
||
product.manual_parse_started_at = None
|
||
product.manual_parse_finished_at = None
|
||
product.manual_reviewed_by = None
|
||
product.manual_reviewed_at = None
|
||
db.session.commit()
|
||
return {"code": 0, "data": product.to_dict()}
|
||
|
||
def parse_manual(self, product_id: str) -> dict:
|
||
product = PptProduct.query.get(product_id)
|
||
if not product:
|
||
return {"code": 1002, "message": "产品不存在", "data": None}
|
||
if not product.manual_file_url:
|
||
return {"code": 1003, "message": "请先上传小册子", "data": None}
|
||
if not os.path.exists(product.manual_file_url):
|
||
return {"code": 1004, "message": "小册子文件不存在，请重新上传", "data": None}
|
||
|
||
if product.manual_parse_status in ("queued", "parsing"):
|
||
return {"code": 0, "message": "解析任务正在进行", "data": product.to_dict()}
|
||
|
||
# 先提交状态，避免 Worker 抢先执行时读到 pending 而跳过任务。
|
||
product.manual_parse_status = "queued"
|
||
product.manual_parse_message = "任务已提交，等待解析..."
|
||
product.manual_parse_task_id = None
|
||
product.manual_parse_error = None
|
||
product.manual_parse_started_at = None
|
||
product.manual_parse_finished_at = None
|
||
db.session.commit()
|
||
|
||
# 提交 Celery 异步任务到专用队列。
|
||
from insurance.generation.celery_tasks import parse_product_manual_task
|
||
try:
|
||
result = parse_product_manual_task.apply_async(args=[product_id], queue="insurance")
|
||
product.manual_parse_task_id = result.id
|
||
db.session.commit()
|
||
except Exception as exc:
|
||
logger.error(f"提交小册子解析任务失败: {exc}", exc_info=True)
|
||
product.manual_parse_status = "failed"
|
||
product.manual_parse_message = "任务提交失败"
|
||
product.manual_parse_error = str(exc)[:1000]
|
||
db.session.commit()
|
||
return {"code": 1005, "message": "解析任务提交失败，请稍后重试", "data": product.to_dict()}
|
||
return {"code": 0, "data": product.to_dict()}
|
||
|
||
def get_manual(self, product_id: str) -> dict:
|
||
"""获取产品小册子解析详情。"""
|
||
product = PptProduct.query.get(product_id)
|
||
if not product:
|
||
return {"code": 1002, "message": "产品不存在", "data": None}
|
||
return {"code": 0, "data": product.to_dict()}
|
||
|
||
def review_manual(self, product_id: str, data: dict) -> dict:
|
||
product = PptProduct.query.get(product_id)
|
||
if not product:
|
||
return {"code": 1002, "message": "产品不存在", "data": None}
|
||
if product.manual_parse_status not in ("parsed", "reviewed"):
|
||
return {"code": 1003, "message": "产品尚未解析，无法核对", "data": None}
|
||
if "rules" in data:
|
||
product.manual_parsed_rules = json.dumps(data["rules"], ensure_ascii=False)
|
||
if data.get("confirm", False):
|
||
product.manual_parse_status = "reviewed"
|
||
product.manual_reviewed_by = data.get("reviewedBy", "")
|
||
from datetime import datetime
|
||
product.manual_reviewed_at = datetime.now()
|
||
db.session.commit()
|
||
return {"code": 0, "data": product.to_dict()}
|
||
|
||
# ---- PPT 模板管理 ----
|
||
|
||
def list_scenarios(self) -> dict:
|
||
items = PptScenario.query.filter(
|
||
PptScenario.deleted_at.is_(None)
|
||
).order_by(PptScenario.sort_order.asc(), PptScenario.code.asc()).all()
|
||
return {"code": 0, "data": {"items": [item.to_dict() for item in items]}}
|
||
|
||
def create_scenario(self, data: dict) -> dict:
|
||
code = str(data.get("code") or "").strip()
|
||
name = str(data.get("name") or "").strip()
|
||
mode = str(data.get("generationMode") or "single").strip()
|
||
if not code or not name:
|
||
return {"code": 1001, "message": "场景编码和名称必填", "data": None}
|
||
if mode not in ("single", "compare", "portfolio"):
|
||
return {"code": 1001, "message": "生成模式无效", "data": None}
|
||
if PptScenario.query.get(code):
|
||
return {"code": 1001, "message": "场景编码已存在", "data": None}
|
||
scenario = PptScenario(
|
||
code=code,
|
||
name=name,
|
||
base_scenario=data.get("baseScenario") or None,
|
||
generation_mode=mode,
|
||
description=data.get("description") or "",
|
||
status=data.get("status", 1),
|
||
sort_order=data.get("sortOrder", 0),
|
||
is_builtin=False,
|
||
)
|
||
db.session.add(scenario)
|
||
db.session.commit()
|
||
return {"code": 0, "data": scenario.to_dict()}
|
||
|
||
def update_scenario(self, code: str, data: dict) -> dict:
|
||
scenario = PptScenario.query.filter_by(code=code, deleted_at=None).first()
|
||
if not scenario:
|
||
return {"code": 1002, "message": "场景不存在", "data": None}
|
||
for key, attr in [
|
||
("name", "name"),
|
||
("baseScenario", "base_scenario"),
|
||
("description", "description"),
|
||
("status", "status"),
|
||
("sortOrder", "sort_order"),
|
||
]:
|
||
if key in data:
|
||
setattr(scenario, attr, data[key])
|
||
if "generationMode" in data:
|
||
if data["generationMode"] not in ("single", "compare", "portfolio"):
|
||
return {"code": 1001, "message": "生成模式无效", "data": None}
|
||
scenario.generation_mode = data["generationMode"]
|
||
db.session.commit()
|
||
return {"code": 0, "data": scenario.to_dict()}
|
||
|
||
def delete_scenario(self, code: str, user_id: str = "system") -> dict:
|
||
scenario = PptScenario.query.filter_by(code=code, deleted_at=None).first()
|
||
if not scenario:
|
||
return {"code": 1002, "message": "场景不存在", "data": None}
|
||
if scenario.is_builtin:
|
||
return {"code": 1003, "message": "内置场景不可删除，可改为停用", "data": None}
|
||
if PptTemplate.query.filter_by(scenario_tag=code, deleted_at=None).first():
|
||
return {"code": 1003, "message": "仍有 PPT 模板引用该场景，请先调整模板", "data": None}
|
||
from datetime import datetime
|
||
scenario.status = 0
|
||
scenario.deleted_at = datetime.now()
|
||
db.session.commit()
|
||
from insurance.utils.audit import log_operation
|
||
log_operation(user_id, "delete", "ppt_scenario", code, {"softDelete": True})
|
||
return {"code": 0, "data": None}
|
||
|
||
def list_templates(self, params: dict) -> dict:
|
||
query = db.session.query(PptTemplate).filter(PptTemplate.deleted_at.is_(None))
|
||
if params.get("plan_type"):
|
||
query = query.filter(PptTemplate.plan_type == params["plan_type"])
|
||
if params.get("status") is not None:
|
||
query = query.filter(PptTemplate.status == params["status"])
|
||
page, page_size = _safe_page_params(params)
|
||
total = query.count()
|
||
items = query.offset((page - 1) * page_size).limit(page_size).all()
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"total": total,
|
||
"items": [t.to_dict() for t in items],
|
||
},
|
||
}
|
||
|
||
def create_template(self, data: dict) -> dict:
|
||
if not data.get("id"):
|
||
return {"code": 1001, "message": "id 必填", "data": None}
|
||
if PptTemplate.query.get(data["id"]):
|
||
return {"code": 1001, "message": "模板 ID 已存在", "data": None}
|
||
template = PptTemplate(
|
||
id=data["id"],
|
||
plan_type=data.get("planType", "savings"),
|
||
style_preset=data.get("stylePreset", "broker"),
|
||
name=data.get("name"),
|
||
scenario_tag=data.get("scenarioTag"),
|
||
preview_image=data.get("previewImage"),
|
||
applicable_company_ids=json.dumps(data.get("applicableCompanyIds", []), ensure_ascii=False) if data.get("applicableCompanyIds") else None,
|
||
applicable_product_ids=json.dumps(data.get("applicableProductIds", []), ensure_ascii=False) if data.get("applicableProductIds") else None,
|
||
slides_config_json=json.dumps(data.get("slidesConfig", []), ensure_ascii=False) if data.get("slidesConfig") else None,
|
||
status=data.get("status", 1),
|
||
)
|
||
db.session.add(template)
|
||
db.session.commit()
|
||
return {"code": 0, "data": template.to_dict()}
|
||
|
||
def upload_template(self, file, data: dict, template_id: str | None = None) -> dict:
|
||
"""上传 PPTX，自动解析页面结构并创建或替换模板资产。"""
|
||
from insurance.ppt.template_asset_service import (
|
||
delete_stored_template,
|
||
parse_template_pptx,
|
||
save_uploaded_template,
|
||
template_asset_sha256,
|
||
)
|
||
|
||
resolved_id = template_id or str(data.get("id") or "").strip()
|
||
if not resolved_id:
|
||
return {"code": 1001, "message": "模板 ID 必填", "data": None}
|
||
|
||
template = PptTemplate.query.get(resolved_id)
|
||
if template_id and not template:
|
||
return {"code": 1002, "message": "模板不存在", "data": None}
|
||
if not template_id and template:
|
||
return {"code": 1001, "message": "模板 ID 已存在", "data": None}
|
||
|
||
new_asset_id = None
|
||
try:
|
||
new_asset_id, file_path = save_uploaded_template(file, resolved_id)
|
||
parsed = parse_template_pptx(file_path)
|
||
asset_sha256 = template_asset_sha256(file_path)
|
||
except ValueError as exc:
|
||
delete_stored_template(new_asset_id)
|
||
return {"code": 1001, "message": str(exc), "data": None}
|
||
|
||
old_asset_id = template.source_template_asset_id if template else None
|
||
old_asset_version = int(template.asset_version or 0) if template else 0
|
||
if template is None:
|
||
template = PptTemplate(id=resolved_id)
|
||
db.session.add(template)
|
||
|
||
template.plan_type = data.get("planType") or template.plan_type or "savings"
|
||
template.style_preset = data.get("stylePreset") or template.style_preset or "broker"
|
||
template.name = data.get("name") or template.name or file.filename
|
||
template.scenario_tag = data.get("scenarioTag") or template.scenario_tag
|
||
template.source_template_asset_id = new_asset_id
|
||
template.asset_sha256 = asset_sha256
|
||
template.asset_version = old_asset_version + 1
|
||
template.clone_ready = True
|
||
template.clone_renderer = "clone-edit-v2"
|
||
template.required_page_types_json = json.dumps(
|
||
parsed["requiredPageTypes"], ensure_ascii=False
|
||
)
|
||
template.slides_config_json = json.dumps(
|
||
parsed["slidesConfig"], ensure_ascii=False
|
||
)
|
||
template.status = int(data.get("status", template.status if template.status is not None else 1))
|
||
try:
|
||
db.session.commit()
|
||
except Exception:
|
||
db.session.rollback()
|
||
delete_stored_template(new_asset_id)
|
||
raise
|
||
# 旧资产可能仍被排队任务的不可变快照引用，不能在切换当前版本时删除。
|
||
# 物理清理由保留期任务统一处理。
|
||
|
||
result = template.to_dict()
|
||
result["slideCount"] = parsed["slideCount"]
|
||
result["dimensions"] = {
|
||
"width": parsed["width"],
|
||
"height": parsed["height"],
|
||
}
|
||
result["previousAssetId"] = old_asset_id
|
||
return {"code": 0, "data": result}
|
||
|
||
def update_template(self, template_id: str, data: dict) -> dict:
|
||
template = PptTemplate.query.get(template_id)
|
||
if not template or template.deleted_at:
|
||
return {"code": 1002, "message": "模板不存在", "data": None}
|
||
for key, attr in [
|
||
("name", "name"),
|
||
("planType", "plan_type"),
|
||
("stylePreset", "style_preset"),
|
||
("scenarioTag", "scenario_tag"),
|
||
("previewImage", "preview_image"),
|
||
]:
|
||
if key in data:
|
||
setattr(template, attr, data[key])
|
||
if "applicableCompanyIds" in data:
|
||
template.applicable_company_ids = json.dumps(data["applicableCompanyIds"], ensure_ascii=False) if data["applicableCompanyIds"] else None
|
||
if "applicableProductIds" in data:
|
||
template.applicable_product_ids = json.dumps(data["applicableProductIds"], ensure_ascii=False) if data["applicableProductIds"] else None
|
||
if "slidesConfig" in data:
|
||
template.slides_config_json = json.dumps(data["slidesConfig"], ensure_ascii=False) if data["slidesConfig"] else None
|
||
if "status" in data:
|
||
template.status = data["status"]
|
||
db.session.commit()
|
||
return {"code": 0, "data": template.to_dict()}
|
||
|
||
def update_template_status(self, template_id: str, data: dict) -> dict:
|
||
template = PptTemplate.query.get(template_id)
|
||
if not template or template.deleted_at:
|
||
return {"code": 1002, "message": "模板不存在", "data": None}
|
||
template.status = data.get("status", 1)
|
||
db.session.commit()
|
||
return {"code": 0, "data": template.to_dict()}
|
||
|
||
def delete_template(self, template_id: str, user_id: str = "system") -> dict:
|
||
template = PptTemplate.query.filter_by(id=template_id, deleted_at=None).first()
|
||
if not template:
|
||
return {"code": 1002, "message": "模板不存在", "data": None}
|
||
if str(template.source_template_asset_id or "").startswith("builtin://"):
|
||
return {"code": 1003, "message": "内置模板不可删除，可将其停用", "data": None}
|
||
from datetime import datetime
|
||
template.status = 0
|
||
template.deleted_at = datetime.now()
|
||
db.session.commit()
|
||
from insurance.utils.audit import log_operation
|
||
log_operation(user_id, "delete", "ppt_template", template_id, {"softDelete": True})
|
||
return {"code": 0, "data": None}
|
||
|
||
# ---- 海报模板管理 ----
|
||
|
||
def list_poster_templates(self, params: dict) -> dict:
|
||
query = db.session.query(PosterTemplate)
|
||
if params.get("status") is not None:
|
||
query = query.filter(PosterTemplate.status == params["status"])
|
||
page, page_size = _safe_page_params(params)
|
||
total = query.count()
|
||
items = query.offset((page - 1) * page_size).limit(page_size).all()
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"total": total,
|
||
"items": [t.to_dict() for t in items],
|
||
},
|
||
}
|
||
|
||
def create_poster_template(self, data: dict) -> dict:
|
||
if not data.get("name") or not data.get("styleDescription"):
|
||
return {"code": 1001, "message": "name 和 styleDescription 必填", "data": None}
|
||
modes = data.get("supportedModes") or ["single", "long"]
|
||
formats = data.get("supportedFormats") or [
|
||
"single_2_3", "single_9_16", "long_1242_auto",
|
||
]
|
||
compatibility_error = _poster_compatibility_error(modes, formats)
|
||
if compatibility_error:
|
||
return {"code": 1001, "message": compatibility_error, "data": None}
|
||
template = PosterTemplate(
|
||
name=data["name"],
|
||
scenario_tag=data.get("scenarioTag"),
|
||
style_description=data["styleDescription"],
|
||
color_scheme=json.dumps(data["colorScheme"], ensure_ascii=False) if data.get("colorScheme") else None,
|
||
reference_image=data.get("referenceImage"),
|
||
preview_image=data.get("previewImage"),
|
||
layout_key=data.get("layoutKey") or "legacy",
|
||
supported_modes=json.dumps(modes, ensure_ascii=False),
|
||
supported_formats=json.dumps(formats, ensure_ascii=False),
|
||
status=data.get("status", 1),
|
||
)
|
||
db.session.add(template)
|
||
db.session.commit()
|
||
return {"code": 0, "data": template.to_dict()}
|
||
|
||
def update_poster_template(self, template_id: int, data: dict) -> dict:
|
||
template = PosterTemplate.query.get(template_id)
|
||
if not template:
|
||
return {"code": 1002, "message": "模板不存在", "data": None}
|
||
for key, attr in [("name", "name"), ("scenarioTag", "scenario_tag"),
|
||
("styleDescription", "style_description"),
|
||
("referenceImage", "reference_image"), ("previewImage", "preview_image")]:
|
||
if key in data:
|
||
setattr(template, attr, data[key])
|
||
if "colorScheme" in data:
|
||
template.color_scheme = json.dumps(data["colorScheme"], ensure_ascii=False) if data["colorScheme"] else None
|
||
if "layoutKey" in data:
|
||
template.layout_key = data["layoutKey"] or "legacy"
|
||
if "supportedModes" in data or "supportedFormats" in data:
|
||
current = template.to_dict()
|
||
modes = data.get("supportedModes", current["supportedModes"])
|
||
formats = data.get("supportedFormats", current["supportedFormats"])
|
||
compatibility_error = _poster_compatibility_error(modes, formats)
|
||
if compatibility_error:
|
||
return {"code": 1001, "message": compatibility_error, "data": None}
|
||
template.supported_modes = json.dumps(modes, ensure_ascii=False)
|
||
template.supported_formats = json.dumps(formats, ensure_ascii=False)
|
||
if "status" in data:
|
||
template.status = data["status"]
|
||
db.session.commit()
|
||
return {"code": 0, "data": template.to_dict()}
|
||
|
||
def update_poster_template_status(self, template_id: int, data: dict) -> dict:
|
||
template = PosterTemplate.query.get(template_id)
|
||
if not template:
|
||
return {"code": 1002, "message": "模板不存在", "data": None}
|
||
template.status = data.get("status", 1)
|
||
db.session.commit()
|
||
return {"code": 0, "data": template.to_dict()}
|
||
|
||
# ---- 文案模板管理 ----
|
||
|
||
def list_copy_templates(self, params: dict) -> dict:
|
||
query = db.session.query(PosterCopyTemplate).filter(
|
||
PosterCopyTemplate.deleted_at.is_(None)
|
||
)
|
||
if params.get("status") is not None:
|
||
query = query.filter(PosterCopyTemplate.status == params["status"])
|
||
page, page_size = _safe_page_params(params)
|
||
total = query.count()
|
||
items = query.offset((page - 1) * page_size).limit(page_size).all()
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"total": total,
|
||
"items": [t.to_dict() for t in items],
|
||
},
|
||
}
|
||
|
||
def create_copy_template(self, data: dict) -> dict:
|
||
if not data.get("name") or not data.get("content"):
|
||
return {"code": 1001, "message": "name 和 content 必填", "data": None}
|
||
template = PosterCopyTemplate(
|
||
name=data["name"],
|
||
scenario_tag=data.get("scenarioTag"),
|
||
content=data["content"],
|
||
variables=json.dumps(data.get("variables", []), ensure_ascii=False) if data.get("variables") else None,
|
||
status=data.get("status", 1),
|
||
)
|
||
db.session.add(template)
|
||
db.session.commit()
|
||
return {"code": 0, "data": template.to_dict()}
|
||
|
||
def update_copy_template(self, template_id: int, data: dict) -> dict:
|
||
template = PosterCopyTemplate.query.get(template_id)
|
||
if not template or template.deleted_at:
|
||
return {"code": 1002, "message": "模板不存在", "data": None}
|
||
for key, attr in [("name", "name"), ("scenarioTag", "scenario_tag"), ("content", "content")]:
|
||
if key in data:
|
||
setattr(template, attr, data[key])
|
||
if "variables" in data:
|
||
template.variables = json.dumps(data["variables"], ensure_ascii=False) if data["variables"] else None
|
||
if "status" in data:
|
||
template.status = data["status"]
|
||
db.session.commit()
|
||
return {"code": 0, "data": template.to_dict()}
|
||
|
||
def delete_copy_template(self, template_id: int, user_id: str = "system") -> dict:
|
||
template = PosterCopyTemplate.query.filter_by(
|
||
id=template_id, deleted_at=None
|
||
).first()
|
||
if not template:
|
||
return {"code": 1002, "message": "模板不存在", "data": None}
|
||
from datetime import datetime
|
||
template.status = 0
|
||
template.deleted_at = datetime.now()
|
||
db.session.commit()
|
||
from insurance.utils.audit import log_operation
|
||
log_operation(
|
||
user_id, "delete", "poster_copy_template", str(template_id),
|
||
{"softDelete": True},
|
||
)
|
||
return {"code": 0, "data": None}
|
||
|
||
# ---- 历史记录管理 ----
|
||
|
||
def list_history(self, params: dict) -> dict:
|
||
query = db.session.query(PptHistory)
|
||
if params.get("user_id"):
|
||
query = query.filter(PptHistory.user_id == params["user_id"])
|
||
if params.get("company_id"):
|
||
query = query.filter(PptHistory.company_id == params["company_id"])
|
||
if params.get("action_type"):
|
||
query = query.filter(PptHistory.action_type == params["action_type"])
|
||
query = query.order_by(PptHistory.created_at.desc())
|
||
page, page_size = _safe_page_params(params)
|
||
total = query.count()
|
||
items = query.offset((page - 1) * page_size).limit(page_size).all()
|
||
return {
|
||
"code": 0,
|
||
"data": {
|
||
"total": total,
|
||
"items": [h.to_dict() for h in items],
|
||
},
|
||
}
|
||
|
||
def delete_history(self, history_id: int) -> dict:
|
||
record = PptHistory.query.get(history_id)
|
||
if not record:
|
||
return {"code": 1002, "message": "记录不存在", "data": None}
|
||
db.session.delete(record)
|
||
db.session.commit()
|
||
return {"code": 0, "data": None}
|
||
|
||
def export_history_csv(self, params: dict):
|
||
"""导出历史记录为 CSV。"""
|
||
import csv
|
||
import io
|
||
query = db.session.query(PptHistory)
|
||
if params.get("user_id"):
|
||
query = query.filter(PptHistory.user_id == params["user_id"])
|
||
if params.get("company_id"):
|
||
query = query.filter(PptHistory.company_id == params["company_id"])
|
||
if params.get("action_type"):
|
||
query = query.filter(PptHistory.action_type == params["action_type"])
|
||
query = query.order_by(PptHistory.created_at.desc())
|
||
items = query.limit(10000).all() # 限制最大导出行数
|
||
|
||
output = io.StringIO()
|
||
output.write("") # UTF-8 BOM，确保 Excel 正确显示中文
|
||
writer = csv.writer(output)
|
||
writer.writerow(["ID", "用户ID", "会话ID", "操作类型", "保司ID", "产品ID", "文件地址", "时间"])
|
||
for h in items:
|
||
writer.writerow([
|
||
h.id, h.user_id, h.session_id or "", h.action_type,
|
||
h.company_id or "", h.product_id or "",
|
||
h.file_url or "", str(h.created_at) if h.created_at else "",
|
||
])
|
||
return output.getvalue()
|
||
|
||
# ---- 系统配置 ----
|
||
|
||
# 内置常用模型列表（Dify 不可用时的降级方案）
|
||
_BUILTIN_MODELS = [
|
||
{"provider": "deepseek", "model": "deepseek-chat", "label": "DeepSeek Chat"},
|
||
{"provider": "deepseek", "model": "deepseek-reasoner", "label": "DeepSeek Reasoner"},
|
||
{"provider": "minimax", "model": "MiniMax-2.7-Flash", "label": "MiniMax 2.7 Flash"},
|
||
{"provider": "gemini", "model": "gemini-2.5-flash", "label": "Gemini 2.5 Flash"},
|
||
{"provider": "gemini", "model": "gemini-2.5-pro", "label": "Gemini 2.5 Pro"},
|
||
{"provider": "openai", "model": "gpt-4o", "label": "GPT-4o"},
|
||
{"provider": "openai", "model": "gpt-4o-mini", "label": "GPT-4o Mini"},
|
||
{"provider": "openai", "model": "gpt-image-1", "label": "GPT Image 1"},
|
||
]
|
||
|
||
def get_available_models(self) -> dict:
|
||
"""获取可用 LLM 模型列表，优先从 Dify 获取，失败时返回内置列表。"""
|
||
# 尝试从 Dify 获取
|
||
dify_models = self._fetch_dify_models()
|
||
if dify_models is not None:
|
||
return {"code": 0, "data": {"models": dify_models, "source": "dify"}}
|
||
return {"code": 0, "data": {"models": self._BUILTIN_MODELS, "source": "builtin"}}
|
||
|
||
# 模型名前缀 → 品牌名映射（Dify 用 openai_api_compatible 统一接口，需要从模型名推断品牌）
|
||
_MODEL_BRAND_MAP = {
|
||
"deepseek": "DeepSeek",
|
||
"gpt": "OpenAI",
|
||
"o1": "OpenAI",
|
||
"o3": "OpenAI",
|
||
"o4": "OpenAI",
|
||
"claude": "Anthropic",
|
||
"gemini": "Google",
|
||
"qwen": "通义千问",
|
||
"glm": "智谱",
|
||
"cogview": "智谱",
|
||
"MiniMax": "MiniMax",
|
||
"moonshot": "月之暗面",
|
||
"doubao": "豆包",
|
||
}
|
||
|
||
def _infer_brand(self, model_name: str) -> str:
|
||
"""从模型名推断品牌名。"""
|
||
for prefix, brand in self._MODEL_BRAND_MAP.items():
|
||
if model_name.lower().startswith(prefix.lower()):
|
||
return brand
|
||
return "其他"
|
||
|
||
def _fetch_dify_models(self) -> list | None:
|
||
"""从 Dify 数据库直接查询已配置的 LLM 模型列表。"""
|
||
try:
|
||
rows = db.session.execute(db.text(
|
||
"SELECT DISTINCT pm.model_name, pm.provider_name "
|
||
"FROM provider_models pm "
|
||
"WHERE pm.model_type = 'llm' AND pm.is_valid = true "
|
||
"ORDER BY pm.provider_name, pm.model_name"
|
||
)).fetchall()
|
||
if not rows:
|
||
return None
|
||
models = []
|
||
for row in rows:
|
||
model_name = row[0]
|
||
provider_name = row[1]
|
||
brand = self._infer_brand(model_name)
|
||
models.append({
|
||
"provider": brand,
|
||
"model": model_name,
|
||
"label": f"{brand} / {model_name}",
|
||
})
|
||
return models
|
||
except Exception as e:
|
||
logger.warning(f"从 Dify 数据库获取模型列表失败: {e}")
|
||
return None
|
||
|
||
# 需要掩码处理的敏感 key（包含 api_key 或 secret 等）
|
||
_SENSITIVE_KEYS = {"api_key", "secret", "password", "token"}
|
||
|
||
@staticmethod
|
||
def _mask_value(key: str, value: str) -> str:
|
||
"""对敏感配置项进行掩码，不返回完整密钥。"""
|
||
if not value:
|
||
return value
|
||
key_lower = key.lower()
|
||
if any(s in key_lower for s in PptAdminService._SENSITIVE_KEYS):
|
||
if len(value) <= 4:
|
||
return "****"
|
||
return f"{value[:2]}****{value[-2:]}"
|
||
return value
|
||
|
||
def get_settings(self) -> dict:
|
||
settings = SystemSetting.query.all()
|
||
data = {}
|
||
for s in settings:
|
||
data[s.key] = s.value
|
||
return {
|
||
"code": 0,
|
||
"data": data,
|
||
}
|
||
|
||
# 允许通过 API 写入的设置键白名单
|
||
_ALLOWED_SETTING_KEYS = {
|
||
"ppt_llm_provider", "ppt_llm_model", "ppt_llm_api_key", "ppt_llm_base_url", "ppt_llm_timeout_ms",
|
||
"poster_llm_provider", "poster_llm_model", "poster_llm_api_key", "poster_llm_base_url",
|
||
"poster_image_provider", "poster_image_model", "poster_image_api_key", "poster_image_base_url",
|
||
"poster_history_retention_days", "ppt_history_retention_days",
|
||
"dify_workspace_api_key",
|
||
}
|
||
|
||
@staticmethod
|
||
def _is_masked_value(value: str) -> bool:
|
||
"""判断值是否为掩码格式（如 sk-****abcd）。"""
|
||
return isinstance(value, str) and "****" in value
|
||
|
||
@staticmethod
|
||
def _validate_settings(data: dict) -> str | None:
|
||
"""校验设置值的安全性，返回错误信息或 None。"""
|
||
from insurance.utils.security import is_safe_base_url
|
||
allowed = PptAdminService._ALLOWED_SETTING_KEYS
|
||
for key, value in data.items():
|
||
if key not in allowed:
|
||
return f"不允许的配置键: {key}"
|
||
if not isinstance(value, str):
|
||
continue
|
||
# 校验 Base URL 字段
|
||
if "base_url" in key.lower() and value.strip():
|
||
is_safe, err_msg = is_safe_base_url(value.strip())
|
||
if not is_safe:
|
||
return f"{key}: {err_msg}"
|
||
return None
|
||
|
||
def update_settings(self, data: dict, updated_by: str = "") -> dict:
|
||
# 安全校验（SEC-P1-02）
|
||
validation_error = self._validate_settings(data)
|
||
if validation_error:
|
||
return {"code": 1001, "message": validation_error, "data": None}
|
||
|
||
for key, value in data.items():
|
||
value_str = str(value) if value is not None else ""
|
||
setting = SystemSetting.query.filter_by(key=key).first()
|
||
if setting:
|
||
# 如果是掩码值，跳过更新（保留真实密钥）
|
||
if self._is_masked_value(value_str):
|
||
continue
|
||
setting.value = value_str
|
||
setting.updated_by = updated_by
|
||
else:
|
||
# 新建设置项，不允许掩码值
|
||
if self._is_masked_value(value_str):
|
||
continue
|
||
db.session.add(SystemSetting(key=key, value=value_str, updated_by=updated_by))
|
||
db.session.commit()
|
||
return {"code": 0, "data": None}
|
||
|
||
def sync_models(self, provider: str, api_key: str, base_url: str = "") -> dict:
|
||
"""从供应商 API 拉取可用模型列表。"""
|
||
if not api_key:
|
||
return {"code": 1001, "message": "请填写 API Key", "data": None}
|
||
|
||
try:
|
||
models = self._fetch_provider_models(provider, api_key, base_url)
|
||
except Exception as e:
|
||
logger.warning(f"同步模型失败: {e}")
|
||
return {"code": 5001, "message": f"同步失败: {e}", "data": None}
|
||
|
||
if not models:
|
||
return {"code": 0, "data": {"models": [], "message": "未获取到模型"}}
|
||
|
||
return {"code": 0, "data": {"models": models}}
|
||
|
||
def _fetch_provider_models(self, provider: str, api_key: str, base_url: str) -> list:
|
||
"""根据供应商类型拉取模型列表。"""
|
||
import httpx
|
||
|
||
if provider == "deepseek":
|
||
url = "https://api.deepseek.com/v1/models"
|
||
headers = {"Authorization": f"Bearer {api_key}"}
|
||
resp = httpx.get(url, headers=headers, timeout=10)
|
||
resp.raise_for_status()
|
||
return [m["id"] for m in resp.json().get("data", [])]
|
||
|
||
elif provider == "gemini":
|
||
url = f"https://generativelanguage.googleapis.com/v1/models?key={api_key}"
|
||
resp = httpx.get(url, timeout=10)
|
||
resp.raise_for_status()
|
||
return [m["name"].split("/")[-1] for m in resp.json().get("models", [])]
|
||
|
||
elif provider == "minimax":
|
||
url = "https://api.minimax.chat/v1/models"
|
||
headers = {"Authorization": f"Bearer {api_key}"}
|
||
resp = httpx.get(url, headers=headers, timeout=10)
|
||
resp.raise_for_status()
|
||
data = resp.json()
|
||
models = data.get("models") or data.get("data", [])
|
||
return [m.get("id") or m.get("model", "") for m in models if m]
|
||
|
||
elif provider == "dify":
|
||
return [m["model"] for m in (self._fetch_dify_models() or [])]
|
||
|
||
else:
|
||
# 自定义供应商：OpenAI 兼容 /models 端点
|
||
if not base_url:
|
||
return []
|
||
url = f"{base_url.rstrip('/')}/models"
|
||
headers = {"Authorization": f"Bearer {api_key}"}
|
||
resp = httpx.get(url, headers=headers, timeout=10)
|
||
resp.raise_for_status()
|
||
return [m["id"] for m in resp.json().get("data", [])]
|