"""系统配置 API""" import re from typing import Optional, List from fastapi import APIRouter, Body, Depends from sqlalchemy.orm import Session from pydantic import BaseModel, Field, ConfigDict from app.core.database import get_db from app.core.auth import get_current_user from app.core.response import success_response, error_response from app.core.utils import generate_id from app.models.models import BizSystemConfig from app.crud.base import CRUDBase, get_model_attr router = APIRouter(prefix="/api/web/admin/system-config", tags=["系统配置"]) def _resolve_payload_with_crypto_fallback(payload: dict, current_user: dict): """兼容明文/密文请求，返回业务 payload。失败时返回 error_response。""" req_dict = payload if isinstance(payload, dict) else {} if isinstance(req_dict, dict) and req_dict.get("enc") == 1 and req_dict.get("edata"): try: from app.core import api_crypto from app.core.config import settings ts = req_dict.get("ts") nonce = req_dict.get("nonce") edata = req_dict.get("edata") operator_user_id = current_user.get("user_id") if isinstance(current_user, dict) else None fixed_secret = getattr(settings, "API_ENCRYPT_FIXED_SECRET", "") or "" if not (fixed_secret and operator_user_id and ts is not None and nonce): return {}, error_response(400, "密文解析配置缺失") key = api_crypto.derive_key( fixed_secret=fixed_secret, user_id=str(operator_user_id), ts=int(ts), nonce=str(nonce), ) plain = api_crypto.decrypt_json(str(edata), key) data = plain.get("data", plain) if isinstance(plain, dict) else {} return (data if isinstance(data, dict) else {}), None except Exception as exc: return {}, error_response(400, f"密文解密失败: {exc}") data = req_dict.get("data", req_dict) if isinstance(req_dict, dict) else {} return (data if isinstance(data, dict) else {}), None # 运营端「系统设置」仅存以下键（其余配置走 biz_system_config 但不在该界面维护） _SETTING_KEY_META = { "auto_cancel_minutes": { "response_key": "autoCancelMinutes", "default": 30, "min": 5, "max": 1440, "config_type": "number", "config_name": "订单自动取消时间", "config_group": "order", "description": "超时未支付自动取消订单（分钟）", }, "default_region_expected_delivery_minutes": { "response_key": "defaultRegionExpectedDeliveryMinutes", "default": 600, "min": 1, "max": 10080, "config_type": "number", "config_name": "区域未配置时的默认预计配送时长", "config_group": "order", "description": "分配配送员时，若区域未设置预计配送(分钟)，则配送截止时间=当前时间+本值（分钟）", }, "delivery_timeout_warn_lead_minutes": { "response_key": "deliveryTimeoutWarnLeadMinutes", "default": 30, "min": 1, "max": 1440, "config_type": "number", "config_name": "配送超时预警提前时间", "config_group": "order", "description": "距离配送截止时间不足该分钟数时触发预警提示", }, "auto_confirm_receive_days": { "response_key": "autoConfirmReceiveDays", "default": 7, "min": 1, "max": 365, "config_type": "number", "config_name": "自动确认收货期限", "config_group": "order", "description": "商品送达后，客户超过该天数未确认收货则系统自动确认（天）", }, "customer_service_phone": { "response_key": "servicePhone", "default": "", "max_len": 32, "config_type": "string", "config_name": "客服电话", "config_group": "contact", "description": "小程序一键拨号展示的客服电话", }, } # 运营端「系统设置」页涉及的配置键：首次读取/定时任务读取前若缺失则插入默认值，保证均以 biz_system_config 为准 _WEB_SETTINGS_KEYS = ( "auto_cancel_minutes", "default_region_expected_delivery_minutes", "delivery_timeout_warn_lead_minutes", "auto_confirm_receive_days", "customer_service_phone", ) def ensure_web_system_settings_rows(db: Session, *, commit: bool = True) -> None: """若缺失则插入默认行（与 _SETTING_KEY_META 一致），便于统一从数据库读取。""" seeded = False for config_key in _WEB_SETTINGS_KEYS: if system_config_crud.get_by_key(db, config_key): continue meta = _SETTING_KEY_META[config_key] if meta["config_type"] == "string": val = "" if meta.get("default") in (None, "") else str(meta["default"]) else: val = str(int(meta["default"])) system_config_crud.create_or_update( db, config_key, val, config_type=meta["config_type"], config_name=meta["config_name"], config_group=meta["config_group"], description=meta["description"], create_by="system", create_name="系统", commit=False, ) seeded = True if seeded and commit: db.commit() def _parse_int_setting(raw: Optional[str], default: int) -> int: if raw is None or str(raw).strip() == "": return default try: return int(float(raw)) except (TypeError, ValueError): return default class OrderSettingsUpdate(BaseModel): model_config = ConfigDict(populate_by_name=True) auto_cancel_minutes: Optional[int] = Field(None, alias="autoCancelMinutes", ge=5, le=1440) default_region_expected_delivery_minutes: Optional[int] = Field( None, alias="defaultRegionExpectedDeliveryMinutes", ge=1, le=10080 ) delivery_timeout_warn_lead_minutes: Optional[int] = Field( None, alias="deliveryTimeoutWarnLeadMinutes", ge=1, le=1440 ) auto_confirm_receive_days: Optional[int] = Field( None, alias="autoConfirmReceiveDays", ge=1, le=365 ) class ContactSettingsUpdate(BaseModel): model_config = ConfigDict(populate_by_name=True) service_phone: Optional[str] = Field(None, alias="servicePhone", max_length=32) class SystemSettingsUpdateBody(BaseModel): model_config = ConfigDict(populate_by_name=True) order: Optional[OrderSettingsUpdate] = None contact: Optional[ContactSettingsUpdate] = None class SystemConfigCRUD(CRUDBase[BizSystemConfig]): """系统配置CRUD""" def __init__(self): super().__init__(BizSystemConfig) def get_by_key(self, db: Session, config_key: str) -> Optional[BizSystemConfig]: """根据配置键获取配置""" return db.query(self.model).filter( self.model.config_key == config_key, self.model.is_del == 0 ).first() def create_or_update( self, db: Session, config_key: str, config_value: str, config_type: str = "string", config_name: str = None, config_group: str = None, description: str = None, is_active: int = 1, create_by: str = None, create_name: str = None, update_by: str = None, commit: bool = True, ) -> BizSystemConfig: """创建或更新配置""" existing = db.query(self.model).filter(self.model.config_key == config_key).first() if existing: existing.config_value = config_value existing.config_type = config_type if config_name: existing.config_name = config_name if config_group: existing.config_group = config_group if description: existing.description = description existing.is_active = is_active if hasattr(existing, "is_del"): existing.is_del = 0 if update_by is not None: existing.update_by = update_by if commit: db.commit() db.refresh(existing) else: db.flush() return existing else: data = { "id": generate_id(), "config_key": config_key, "config_value": config_value, "config_type": config_type, "config_name": config_name, "config_group": config_group, "description": description, "is_active": is_active, "create_by": create_by, "create_name": create_name } obj = self.model() for key, value in data.items(): attr_name = get_model_attr(obj, key) if attr_name: setattr(obj, attr_name, value) if not obj.id: obj.id = generate_id() db.add(obj) if commit: db.commit() db.refresh(obj) else: db.flush() return obj def batch_update_status( self, db: Session, ids: List[str], is_active: int ) -> int: """批量更新状态""" count = db.query(self.model).filter( self.model.id.in_(ids) ).update({"is_active": is_active}, synchronize_session=False) db.commit() return count system_config_crud = SystemConfigCRUD() def _clamp_to_meta(value: int, meta: dict) -> int: return max(meta["min"], min(meta["max"], value)) def _read_setting_int(db: Session, config_key: str) -> int: meta = _SETTING_KEY_META[config_key] row = system_config_crud.get_by_key(db, config_key) if not row: return meta["default"] parsed = _parse_int_setting(row.config_value, meta["default"]) return _clamp_to_meta(parsed, meta) def _read_setting_str(db: Session, config_key: str) -> str: meta = _SETTING_KEY_META[config_key] default = meta.get("default", "") max_len = int(meta.get("max_len", 255)) row = system_config_crud.get_by_key(db, config_key) if not row or row.config_value is None: s = "" if default is None else str(default) return s.strip()[:max_len] return str(row.config_value).strip()[:max_len] def _normalize_service_phone(value: Optional[str]) -> str: if value is None: return "" s = str(value).strip() if len(s) > 32: raise ValueError("客服电话长度不能超过32个字符") if not s: return "" if not re.fullmatch(r"[\d\-\+\s\(\)]+", s): raise ValueError("客服电话仅支持数字及 - + ( ) 与空格") return s def get_auto_cancel_minutes_for_job(db: Session) -> int: """供定时任务读取：线上单未支付自动取消的分钟数。""" ensure_web_system_settings_rows(db, commit=True) return _read_setting_int(db, "auto_cancel_minutes") def get_auto_confirm_receive_days_for_job(db: Session) -> int: """供定时任务读取：送达后自动确认收货的天数。""" ensure_web_system_settings_rows(db, commit=True) return _read_setting_int(db, "auto_confirm_receive_days") def get_default_region_expected_delivery_minutes(db: Session) -> int: """区域未配置预计配送时长时，分配配送员弹窗使用的默认分钟数。""" ensure_web_system_settings_rows(db, commit=True) return _read_setting_int(db, "default_region_expected_delivery_minutes") def read_customer_service_phone_for_mini(db: Session) -> str: """小程序端展示的客服电话（已清洗长度）。""" ensure_web_system_settings_rows(db, commit=True) return _read_setting_str(db, "customer_service_phone") @router.get("/settings", response_model=dict) def get_system_settings( db: Session = Depends(get_db), current_user: dict = Depends(get_current_user) ): """运营端系统设置 — 数据来自 biz_system_config（配送时效预警请在「区域」中配置）""" ensure_web_system_settings_rows(db, commit=True) order = { "autoCancelMinutes": _read_setting_int(db, "auto_cancel_minutes"), "defaultRegionExpectedDeliveryMinutes": _read_setting_int( db, "default_region_expected_delivery_minutes" ), "deliveryTimeoutWarnLeadMinutes": _read_setting_int( db, "delivery_timeout_warn_lead_minutes" ), "autoConfirmReceiveDays": _read_setting_int(db, "auto_confirm_receive_days"), } contact = { "servicePhone": _read_setting_str(db, "customer_service_phone"), } return success_response({ "order": order, "contact": contact, }) def _parse_drm_from_payload_order(order_raw: Optional[dict]) -> Optional[int]: """从原始 JSON 的 order 中解析 defaultRegionExpectedDeliveryMinutes（兼容解析异常）。""" if not isinstance(order_raw, dict): return None raw_v = order_raw.get("defaultRegionExpectedDeliveryMinutes") if raw_v is None: return None try: return int(float(raw_v)) except (TypeError, ValueError): return None @router.put("/settings", response_model=dict) def update_system_settings( payload: dict = Body(...), db: Session = Depends(get_db), current_user: dict = Depends(get_current_user) ): """更新运营端系统设置（按模块部分更新）；三条配置同一事务提交，避免只落库两条。""" payload, req_err = _resolve_payload_with_crypto_fallback(payload, current_user) if req_err is not None: return req_err try: body = SystemSettingsUpdateBody.model_validate(payload) except Exception as e: return error_response(400, f"参数无效: {str(e)}") if body.order is None and body.contact is None: return error_response(400, "请至少选择一项设置内容") uid = current_user.get("user_id") uname = current_user.get("real_name") or current_user.get("username") or "" order_raw = payload.get("order") if isinstance(payload.get("order"), dict) else None try: ensure_web_system_settings_rows(db, commit=False) updated = False if body.order is not None and body.order.auto_cancel_minutes is not None: k = "auto_cancel_minutes" meta = _SETTING_KEY_META[k] v = _clamp_to_meta(body.order.auto_cancel_minutes, meta) system_config_crud.create_or_update( db, k, str(v), config_type=meta["config_type"], config_name=meta["config_name"], config_group=meta["config_group"], description=meta["description"], create_by=uid, create_name=uname, update_by=uid, commit=False, ) updated = True if body.order is not None and body.order.auto_confirm_receive_days is not None: k_acr = "auto_confirm_receive_days" meta_acr = _SETTING_KEY_META[k_acr] v_acr = _clamp_to_meta(body.order.auto_confirm_receive_days, meta_acr) system_config_crud.create_or_update( db, k_acr, str(v_acr), config_type=meta_acr["config_type"], config_name=meta_acr["config_name"], config_group=meta_acr["config_group"], description=meta_acr["description"], create_by=uid, create_name=uname, update_by=uid, commit=False, ) updated = True if body.order is not None and body.order.delivery_timeout_warn_lead_minutes is not None: k_warn = "delivery_timeout_warn_lead_minutes" meta_warn = _SETTING_KEY_META[k_warn] v_warn = _clamp_to_meta(body.order.delivery_timeout_warn_lead_minutes, meta_warn) system_config_crud.create_or_update( db, k_warn, str(v_warn), config_type=meta_warn["config_type"], config_name=meta_warn["config_name"], config_group=meta_warn["config_group"], description=meta_warn["description"], create_by=uid, create_name=uname, update_by=uid, commit=False, ) updated = True if body.order is not None: k_drm = "default_region_expected_delivery_minutes" meta_drm = _SETTING_KEY_META[k_drm] drm = body.order.default_region_expected_delivery_minutes if drm is None: drm = _parse_drm_from_payload_order(order_raw) if drm is None: drm = _read_setting_int(db, k_drm) v_drm = _clamp_to_meta(int(drm), meta_drm) system_config_crud.create_or_update( db, k_drm, str(v_drm), config_type=meta_drm["config_type"], config_name=meta_drm["config_name"], config_group=meta_drm["config_group"], description=meta_drm["description"], create_by=uid, create_name=uname, update_by=uid, commit=False, ) updated = True if body.contact is not None and body.contact.service_phone is not None: try: phone_norm = _normalize_service_phone(body.contact.service_phone) except ValueError as e: return error_response(400, str(e)) k = "customer_service_phone" meta = _SETTING_KEY_META[k] system_config_crud.create_or_update( db, k, phone_norm, config_type=meta["config_type"], config_name=meta["config_name"], config_group=meta["config_group"], description=meta["description"], create_by=uid, create_name=uname, update_by=uid, commit=False, ) updated = True if not updated: return error_response(400, "没有可保存的字段") db.commit() return success_response({"message": "保存成功"}) except Exception as e: db.rollback() return error_response(500, f"保存失败: {str(e)}") class SystemConfigCreateRequest(BaseModel): """创建系统配置请求""" config_key: str = Field(..., description="配置键") config_value: str = Field(..., description="配置值") config_type: str = Field("string", description="配置类型: string, number, boolean, json") config_name: str = Field(..., description="配置名称") config_group: str = Field(None, description="配置分组") description: str = Field(None, description="描述") is_active: int = Field(1, description="是否启用") @router.post("/create", response_model=dict) def create_config( request: SystemConfigCreateRequest, db: Session = Depends(get_db), current_user: dict = Depends(get_current_user) ): """创建系统配置""" try: # 检查配置键是否已存在 existing = system_config_crud.get_by_key(db, request.config_key) if existing: return error_response(400, "配置键已存在") config = system_config_crud.create( db=db, data={ "id": generate_id(), "config_key": request.config_key, "config_value": request.config_value, "config_type": request.config_type, "config_name": request.config_name, "config_group": request.config_group, "description": request.description, "is_active": request.is_active, "create_by": current_user.get("user_id"), "create_name": current_user.get("real_name") } ) return success_response({ "id": config.id, "message": "配置创建成功" }) except Exception as e: return error_response(500, f"创建配置失败: {str(e)}") @router.post("/update/{config_id}", response_model=dict) def update_config( config_id: str, request: SystemConfigCreateRequest, db: Session = Depends(get_db), current_user: dict = Depends(get_current_user) ): """更新系统配置""" try: config = system_config_crud.get(db, config_id) if not config: return error_response(404, "配置不存在") if config.is_del == 1: return error_response(404, "配置已删除") # 如果修改了配置键，检查是否冲突 if request.config_key != config.config_key: existing = system_config_crud.get_by_key(db, request.config_key) if existing: return error_response(400, "配置键已存在") config.config_key = request.config_key config.config_value = request.config_value config.config_type = request.config_type config.config_name = request.config_name config.config_group = request.config_group config.description = request.description config.is_active = request.is_active db.commit() db.refresh(config) return success_response({"message": "配置更新成功"}) except Exception as e: return error_response(500, f"更新配置失败: {str(e)}") @router.get("/list", response_model=dict) def get_config_list( page: int = 1, page_size: int = 20, config_name: str = None, config_group: str = None, is_active: int = None, db: Session = Depends(get_db), current_user: dict = Depends(get_current_user) ): """获取系统配置列表""" try: query = db.query(system_config_crud.model).filter(system_config_crud.model.is_del == 0) if config_name: query = query.filter(system_config_crud.model.config_name.like(f"%{config_name}%")) if config_group: query = query.filter(system_config_crud.model.config_group == config_group) if is_active is not None: query = query.filter(system_config_crud.model.is_active == is_active) total = query.count() items = query.order_by(system_config_crud.model.config_group, system_config_crud.model.create_at.desc()).offset((page - 1) * page_size).limit(page_size).all() return success_response({ "list": [_to_response(item) for item in items], "total": total, "page": page, "page_size": page_size }) except Exception as e: return error_response(500, f"获取配置列表失败: {str(e)}") @router.get("/detail/{config_id}", response_model=dict) def get_config_detail( config_id: str, db: Session = Depends(get_db), current_user: dict = Depends(get_current_user) ): """获取配置详情""" try: config = system_config_crud.get(db, config_id) if not config: return error_response(404, "配置不存在") if config.is_del == 1: return error_response(404, "配置已删除") return success_response(_to_response(config)) except Exception as e: return error_response(500, f"获取配置详情失败: {str(e)}") @router.get("/get/{config_key}", response_model=dict) def get_config_by_key( config_key: str, db: Session = Depends(get_db) ): """根据配置键获取配置值""" try: config = system_config_crud.get_by_key(db, config_key) if not config or config.is_del == 1: return error_response(404, "配置不存在") return success_response({ "key": config.config_key, "value": config.config_value, "type": config.config_type }) except Exception as e: return error_response(500, f"获取配置失败: {str(e)}") @router.post("/batch-status", response_model=dict) def batch_update_status( body: dict, db: Session = Depends(get_db), current_user: dict = Depends(get_current_user) ): """批量更新配置状态""" try: ids = body.get("ids", []) is_active = body.get("is_active") if not isinstance(ids, list) or len(ids) == 0: return error_response(400, "ids不能为空") if is_active is None: return error_response(400, "is_active不能为空") count = system_config_crud.batch_update_status(db, ids, is_active) return success_response({"count": count, "message": "批量更新成功"}) except Exception as e: return error_response(500, f"批量更新失败: {str(e)}") @router.delete("/delete/{config_id}", response_model=dict) def delete_config( config_id: str, db: Session = Depends(get_db), current_user: dict = Depends(get_current_user) ): """删除配置""" try: config = system_config_crud.get(db, config_id) if not config: return error_response(404, "配置不存在") config.is_del = 1 db.commit() return success_response({"message": "删除成功"}) except Exception as e: return error_response(500, f"删除配置失败: {str(e)}") def _to_response(config: BizSystemConfig) -> dict: """转换为响应格式""" return { "id": config.id, "config_key": config.config_key, "config_value": config.config_value, "config_type": config.config_type, "config_name": config.config_name, "config_group": config.config_group, "description": config.description, "is_active": config.is_active, "create_at": str(config.create_at) if config.create_at else None, "update_at": str(config.update_at) if config.update_at else None }