"""统一生成任务 Celery 任务定义。 使用 BaoDan 的 Celery 实例，通过 autodiscover 或显式导入注册。 任务通过数据库状态机保证幂等，不依赖 Celery 内置重试。 """ import json import logging from datetime import datetime from celery import shared_task logger = logging.getLogger(__name__) def _update_task_status(task_id: str, **kwargs): """更新任务状态（数据库层面）。""" from insurance.db.compat import db from insurance.models.generation_task import GenerationTask task = GenerationTask.query.get(task_id) if not task: return for key, value in kwargs.items(): if hasattr(task, key): setattr(task, key, value) task.heartbeat_at = datetime.now() db.session.commit() return task def _claim_task(task_id: str) -> bool: """尝试领取任务（queued → running），返回是否成功。""" from insurance.db.compat import db from insurance.models.generation_task import GenerationTask result = db.session.execute( db.text("UPDATE insurance_generation_tasks SET status = 'running', " "started_at = NOW(), heartbeat_at = NOW(), " "attempt_count = attempt_count + 1 " "WHERE id = :id AND status = 'queued'"), {"id": task_id}, ) db.session.commit() return result.rowcount > 0 def _sync_session_progress(session_id: str, progress: int, message: str = None, extractions: list = None, status: str = None, error_message: str = None, workflow_step: str = None): """同步进度到 PptSession（前端轮询读取这张表）。""" from insurance.db.compat import db from insurance.models.ppt_session import PptSession session = PptSession.query.get(session_id) if not session: return session.parse_progress = progress if message is not None: session.parse_message = message if extractions is not None: session.extractions_json = json.dumps(extractions, ensure_ascii=False) if status is not None: session.status = status if error_message is not None: session.parse_error = error_message[:1000] if workflow_step is not None: session.workflow_step = workflow_step if status in ("parsed", "error"): session.parse_finished_at = datetime.now() db.session.commit() # ─── PPT 解析任务 ────────────────────────────────────────── @shared_task(bind=True, name="insurance.parse_ppt", max_retries=3, default_retry_delay=30) def parse_ppt_task(self, task_id: str): """PPT PDF 解析任务。 幂等：通过数据库状态机保证（queued → running → done/failed）。 """ if not _claim_task(task_id): logger.info(f"任务 {task_id} 已被领取或不在 queued 状态，跳过") return _update_task_status(task_id, stage="extracting", progress=5, message="开始解析 PDF") try: _execute_ppt_parse(task_id) except Exception as exc: logger.error(f"PPT 解析任务失败 [{task_id}]: {exc}", exc_info=True) _update_task_status(task_id, status="failed", error_code="parse_error", error_message=str(exc)[:1000], finished_at=datetime.now()) # 同步错误状态到 PptSession from insurance.models.generation_task import GenerationTask task = GenerationTask.query.get(task_id) if task: _sync_session_progress(task.workspace_id, 100, "处理失败", status="error", error_message=str(exc)) raise def _execute_ppt_parse(task_id: str): """执行 PPT 解析逻辑。""" import asyncio import os from insurance.db.compat import db from insurance.models.generation_task import GenerationTask from insurance.models.ppt_session import PptSession from insurance.ppt.extraction import ExtractionOrchestrator task = GenerationTask.query.get(task_id) if not task: return session_id = task.workspace_id session = PptSession.query.get(session_id) if not session: _update_task_status(task_id, status="failed", error_code="workspace_not_found", error_message="工作区不存在", finished_at=datetime.now()) return files = json.loads(session.files_json) if session.files_json else [] if not files: _update_task_status(task_id, status="failed", error_code="no_files", error_message="没有可解析的 PDF 文件", finished_at=datetime.now()) return orchestrator = ExtractionOrchestrator() extractions = [] total = len(files) # 同步初始进度到 PptSession _sync_session_progress(session_id, 5, "正在读取 PDF 文件", status="parsing", workflow_step="parsing") for index, file_info in enumerate(files, start=1): filename = file_info.get("name", "") filepath = file_info.get("path", "") plan_type = file_info.get("type", "savings") company_id = file_info.get("companyId", "") product_id = file_info.get("productId", "") # 查询产品先验信息（名称、别名）传入解析器 product_name_hint = "" product_aliases = [] if product_id: try: from insurance.db.compat import db from insurance.models.ppt_config import PptProduct product = db.session.query(PptProduct).get(product_id) if product: product_name_hint = product.display_name or "" product_aliases = json.loads(product.aliases_json) if product.aliases_json else [] except Exception as e: logger.warning(f"[PPT解析] 查询产品信息失败: {e}") progress = max(5, int((index - 1) / total * 90)) msg = f"正在解析 {filename or f'第 {index} 个文件'}" _update_task_status(task_id, progress=progress, message=msg) _sync_session_progress(session_id, progress, msg, extractions=extractions) def report_file_progress(file_progress: int, stage_message: str): overall = min( 95, int(((index - 1) + max(0, min(file_progress, 100)) / 100) / total * 95), ) _update_task_status( task_id, stage="extracting", progress=overall, message=stage_message ) _sync_session_progress( session_id, overall, stage_message, extractions=extractions ) try: result = asyncio.run(orchestrator.extract_plan( filepath, plan_type, force_reparse=True, progress_callback=report_file_progress, company_id=company_id, product_id=product_id, product_name_hint=product_name_hint, product_aliases=product_aliases, )) extractions.append({ "pdfName": filename, "pdfPath": filepath, "planType": result.plan_type, "status": result.status, "productName": result.product_name, "companyId": company_id, "productId": product_id, "data": result.data, "error": result.error, "yearCount": len(result.data.get("benefit_illustration", [])) if result.data else 0, }) except Exception as exc: logger.error(f"PDF 解析失败 [{filename}]: {exc}", exc_info=True) extractions.append({ "pdfName": filename, "pdfPath": filepath, "planType": plan_type, "companyId": company_id, "productId": product_id, "status": "error", "productName": "unknown", "data": None, "error": str(exc), "yearCount": 0, }) done_progress = min(99, int(index / total * 100)) _sync_session_progress(session_id, done_progress, f"已完成 {index}/{total} 个文件", extractions=extractions) # 更新会话 session = PptSession.query.get(session_id) if not session: return all_failed = all(e.get("status") == "error" for e in extractions) first_error = next( (str(e.get("error")) for e in extractions if e.get("error")), "所有文件均处理失败", ) session.extractions_json = json.dumps(extractions, ensure_ascii=False) session.status = "error" if all_failed else "parsed" session.parse_progress = 100 session.parse_message = "处理失败" if all_failed else "处理完成" session.parse_error = first_error[:1000] if all_failed else None session.parse_finished_at = datetime.now() # 成功时 workflow_step 推进到 review（数据核对），失败保持 parsing session.workflow_step = "parsing" if all_failed else "review" db.session.commit() # 更新任务状态 _update_task_status( task_id, status="failed" if all_failed else "done", stage="completed", progress=100, message="解析失败" if all_failed else "解析完成", error_code="all_failed" if all_failed else "", error_message=first_error[:1000] if all_failed else "", finished_at=datetime.now(), ) if all_failed: raise RuntimeError(first_error) # ─── PPT 生成任务 ────────────────────────────────────────── @shared_task(bind=True, name="insurance.generate_ppt", max_retries=3, default_retry_delay=30) def generate_ppt_task(self, task_id: str): """PPT 生成任务。""" if not _claim_task(task_id): logger.info(f"任务 {task_id} 已被领取或不在 queued 状态，跳过") return _update_task_status(task_id, stage="validating", progress=5, message="开始生成 PPT") # 同步 workflow_step 到工作区 from insurance.db.compat import db as _db from insurance.models.ppt_session import PptSession as _PptSession _session = _PptSession.query.get(task.workspace_id) if _session: _session.workflow_step = "generating" _db.session.commit() try: _execute_ppt_generate(task_id) except Exception as exc: logger.error(f"PPT 生成任务失败 [{task_id}]: {exc}", exc_info=True) _update_task_status(task_id, status="failed", error_code="generate_error", error_message=str(exc)[:1000], finished_at=datetime.now()) # 同步工作区状态 from insurance.models.generation_task import GenerationTask as _GT _task = _GT.query.get(task_id) if _task: from insurance.generation.task_service import sync_workspace_status sync_workspace_status(_task) raise def _execute_ppt_generate(task_id: str): """执行 PPT 生成逻辑。""" import os import uuid as uuid_mod from insurance.db.compat import db from insurance.models.generation_task import GenerationTask from insurance.models.ppt_history import PptHistory from insurance.models.ppt_session import PptSession from insurance.models.ppt_config import PptTemplate, PptCompany, PptProduct from insurance.ppt.normalizer import normalize_savings_plan, normalize_ci_plan, normalize_iul_plan from insurance.ppt.validator import validate_formal_savings_plan, validate_formal_ci_plan, validate_formal_iul_plan from insurance.ppt.renderer import PptRenderer task = GenerationTask.query.get(task_id) if not task: return session = PptSession.query.get(task.workspace_id) if not session: _update_task_status(task_id, status="failed", error_code="workspace_not_found", error_message="工作区不存在", finished_at=datetime.now()) return # 从快照中读取生成参数 snapshot = json.loads(task.input_snapshot_json) if task.input_snapshot_json else {} theme = snapshot.get("theme", "broker") template_id = snapshot.get("templateId", "") company_id = snapshot.get("companyId", "") use_masked_data = bool(snapshot.get("useMaskedData")) requested_scenario = snapshot.get("scenario", "") extractions = json.loads(session.extractions_json) if session.extractions_json else [] _update_task_status(task_id, stage="normalizing", progress=10, message="数据归一化中") # 归一化 all_normalized = [] for ext in extractions: if ext.get("status") not in ("success", "partial") or not ext.get("data"): continue ext_data = ext["data"] pdf_path = ext.get("pdfPath") plan_type = (ext.get("planType") or ext_data.get("product_type") or "savings").lower() try: if plan_type == "ci": normalized = normalize_ci_plan(ext_data, pdf_path) issues = validate_formal_ci_plan(normalized) elif plan_type == "iul": normalized = normalize_iul_plan(ext_data, pdf_path) issues = validate_formal_iul_plan(normalized) else: normalized = normalize_savings_plan(ext_data, pdf_path) issues = validate_formal_savings_plan(normalized) normalized["fileId"] = ext.get("fileId") or ext.get("pdfName", "") normalized["pdfName"] = ext.get("pdfName", "") product_id = ext.get("productId") if product_id: configured_product = PptProduct.query.filter_by( id=product_id, status=1 ).first() if configured_product: product_config = configured_product.to_dict() if use_masked_data: from insurance.ppt.masking import apply_product_mask apply_product_mask(product_config, True) normalized["rawProductName"] = normalized.get("productName", "") normalized["productName"] = product_config["displayName"] normalized["productId"] = configured_product.id normalized["companyId"] = configured_product.company_id normalized["productConfig"] = product_config errors = [i for i in issues if i.level == "error"] if errors: _update_task_status(task_id, status="failed", error_code="validation_error", error_message=f"数据校验不通过: {'; '.join(e.message for e in errors)}", finished_at=datetime.now()) return all_normalized.append(normalized) except Exception as exc: logger.error(f"归一化失败: {exc}", exc_info=True) if not all_normalized: _update_task_status(task_id, status="failed", error_code="no_valid_data", error_message="无有效提取数据", finished_at=datetime.now()) return from insurance.ppt.comparison import ( build_comparison_contract, detect_generation_scenario, generation_mode_for_scenario, ) scenario = detect_generation_scenario(all_normalized) if requested_scenario and requested_scenario != scenario: logger.warning( "PPT 场景已按实际计划书修正: requested=%s, detected=%s", requested_scenario, scenario, ) generation_mode = generation_mode_for_scenario(scenario) try: comparison = build_comparison_contract(all_normalized, mode=generation_mode) except ValueError as ve: _update_task_status(task_id, status="failed", error_code="comparison_validation_error", error_message=str(ve), finished_at=datetime.now()) return _update_task_status(task_id, stage="loading_template", progress=30, message="加载模板") normalized = all_normalized[0] plan_type = normalized.get("kind", "savings") # 加载模板和公司信息 template = None if template_id: template = PptTemplate.query.filter_by( id=template_id, plan_type=plan_type, status=1 ).first() if template and template.scenario_tag and template.scenario_tag != scenario: logger.warning( "所选模板场景不匹配，改用自动场景模板: template=%s, scenario=%s", template.id, scenario, ) template = None if template is None: template = PptTemplate.query.filter_by( scenario_tag=scenario, status=1 ).first() if template is None: template = PptTemplate.query.filter_by( plan_type=plan_type, style_preset=theme, status=1 ).first() template_config = template.to_dict() if template else None if template_config and template.source_template_asset_id: from insurance.ppt.template_asset_service import resolve_template_asset template_config["sourceTemplatePath"] = resolve_template_asset( template.source_template_asset_id ) company_info = None if company_id: company = PptCompany.query.get(company_id) if company: company_info = company.to_dict() if use_masked_data: from insurance.ppt.masking import apply_company_mask apply_company_mask(company_info, True) _update_task_status(task_id, stage="rendering", progress=50, message="渲染 PPT") # 渲染 renderer = PptRenderer() user_id = task.user_id from insurance.config import get_storage_root output_dir = os.path.join(get_storage_root(), "outputs", "ppt", user_id, task_id) os.makedirs(output_dir, exist_ok=True) output_path = os.path.join(output_dir, f"presentation.pptx") result = renderer.render_enhanced( normalized, output_path, theme=theme, company_id=company_id, company_info=company_info, template_config=template_config, all_products=all_normalized if len(all_normalized) > 1 else None, comparison=comparison, generation_mode=generation_mode, scenario=scenario, ) if not result.get("ok"): _update_task_status(task_id, status="failed", error_code="render_error", error_message=f"渲染失败: {result.get('error', '未知错误')}", finished_at=datetime.now()) return _update_task_status(task_id, stage="saving", progress=90, message="保存文件") # 保存 DeckContract 快照（供后续版本化编辑回溯） deck_path = None deck_data = result.get("deck") if deck_data: try: deck_path = os.path.join(output_dir, "deck_contract.json") with open(deck_path, "w", encoding="utf-8") as _f: json.dump(deck_data, _f, ensure_ascii=False, indent=2) logger.info("DeckContract 已保存: %s", deck_path) except Exception as exc: logger.warning("保存 DeckContract 失败: %s", exc) # 解析幻灯片结构（失败不阻断主流程） slides_data = None slides_dir = os.path.join(output_dir, "slides") try: slides_result = renderer.parse_slides(output_path, slides_dir) if slides_result.get("ok"): import json as _json with open(slides_result["jsonPath"], "r", encoding="utf-8") as _f: slides_data = _json.load(_f) logger.info("幻灯片结构解析成功: %d 页", slides_result.get("slideCount", 0)) else: logger.warning("幻灯片结构解析失败: %s", slides_result.get("error", "")) except Exception as exc: logger.warning("幻灯片结构解析异常: %s", exc) # 质量检查（失败不阻断） quality_report = None try: from insurance.ppt.quality_checker import QualityChecker checker = QualityChecker() quality_report = checker.check( pptx_path=output_path, slides_data=slides_data, extractions=extractions, expected_slide_count=result.get("slideCount", 0), ) logger.info("质量检查完成: pass=%s, fail=%s, warn=%s", quality_report["summary"]["pass"], quality_report["summary"]["fail"], quality_report["summary"]["warn"]) except Exception as exc: logger.warning("质量检查异常: %s", exc) # 更新会话 session = PptSession.query.get(task.workspace_id) if session: session.ppt_path = output_path session.slide_count = result.get("slideCount", 0) session.status = "done" session.generated_revision = session.draft_revision session.latest_output_path = output_path # 预览与质量检查 if slides_data: slides_json_path = os.path.join(slides_dir, "slides.json") session.slides_json_path = slides_json_path session.preview_status = "ready" else: session.preview_status = "failed" if quality_report: session.quality_report_json = json.dumps(quality_report, ensure_ascii=False) if deck_path: session.deck_contract_path = deck_path # 追加版本历史 versions = json.loads(session.versions_json) if session.versions_json else [] versions.append({ "revision": session.generated_revision, "path": output_path, "slidesJsonPath": os.path.join(slides_dir, "slides.json") if slides_data else None, "deckPath": deck_path, "slideCount": result.get("slideCount", 0), "createdAt": datetime.now().isoformat(), }) session.versions_json = json.dumps(versions, ensure_ascii=False) db.session.add(PptHistory( user_id=task.user_id, session_id=task.workspace_id, action_type="export", company_id=company_id or None, product_id=(snapshot.get("productIds") or [None])[0], template_id=template_id or None, content_snapshot=json.dumps({ "theme": theme, "slideCount": result.get("slideCount", 0), "useMaskedData": use_masked_data, "scenario": scenario, }, ensure_ascii=False), file_url=output_path, )) db.session.commit() # 完成任务 _update_task_status( task_id, status="done", stage="completed", progress=100, message="生成完成", finished_at=datetime.now(), output_json=json.dumps({ "downloadUrl": f"/insurance/workspace/tasks/{task_id}/download", "slideCount": result.get("slideCount", 0), "filePath": output_path, "scenario": scenario, "generationMode": generation_mode, }, ensure_ascii=False), ) # 同步 workflow_step 到 result session = PptSession.query.get(task.workspace_id) if session: session.workflow_step = "result" db.session.commit() # ─── PPT 重新生成任务（版本化）───────────────────────────── def _apply_edits_to_pptx(pptx_path: str, edit_slides: list): """将 slides.json 中的编辑应用到已渲染的 PPTX 文件。 1. 删除被标记为 hidden 的幻灯片（从后往前删避免索引偏移） 2. 对非隐藏页，按位置匹配文本框并更新文字 """ from pptx import Presentation from pptx.util import Emu prs = Presentation(pptx_path) slides = list(prs.slides) # 收集需要删除的幻灯片索引（倒序处理） hidden_indices = sorted( [i for i, s in enumerate(edit_slides) if s.get("hidden") and i < len(slides)], reverse=True, ) for idx in hidden_indices: slide_id = slides[idx].slide_id rId = prs.slides._sldIdLst[idx].get("{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id") if not rId: # 尝试通过 rels 查找 for rel in prs.part.rels.values(): if rel.target_part is slides[idx].part: rId = rel.rId break if rId: prs.part.drop_rel(rId) del prs.slides._sldIdLst[idx] logger.info("已删除隐藏幻灯片: index=%d", idx) # 应用文字编辑（匹配位置） TOLERANCE = 50000 # EMU 容差（约 0.5px） edited_count = 0 for slide_idx, edit_slide in enumerate(edit_slides): if edit_slide.get("hidden"): continue if slide_idx >= len(list(prs.slides)): continue slide = list(prs.slides)[slide_idx] edit_shapes = edit_slide.get("shapes", []) for edit_shape in edit_shapes: if edit_shape.get("type") != "textbox": continue edit_paras = edit_shape.get("paragraphs", []) if not edit_paras: continue edit_x = edit_shape.get("x", 0) edit_y = edit_shape.get("y", 0) # 匹配 PPTX 中的形状（按位置） for shape in slide.shapes: if not shape.has_text_frame: continue shape_x = int(shape.left) if shape.left else 0 shape_y = int(shape.top) if shape.top else 0 if abs(shape_x - _px_to_emu(edit_x)) > TOLERANCE: continue if abs(shape_y - _px_to_emu(edit_y)) > TOLERANCE: continue # 位置匹配，更新文字 _update_shape_text(shape, edit_paras) edited_count += 1 break if edited_count > 0 or hidden_indices: prs.save(pptx_path) logger.info("PPTX 后处理完成: 编辑 %d 个文本框, 删除 %d 个隐藏页", edited_count, len(hidden_indices)) def _px_to_emu(px: int) -> int: """像素转 EMU（96 DPI）。""" return round(px * 914400 / 96) def _update_shape_text(shape, edit_paras: list): """将编辑后的段落文本写入 python-pptx 形状。""" from pptx.util import Pt from pptx.dml.color import RGBColor tf = shape.text_frame existing_paras = list(tf.paragraphs) for i, edit_para in enumerate(edit_paras): new_text = edit_para.get("text", "") if i < len(existing_paras): para = existing_paras[i] # 保留第一个 run 的格式，替换文本 if para.runs: para.runs[0].text = new_text # 删除多余 runs for run in para.runs[1:]: run.text = "" else: para.text = new_text else: # 新增段落 para = tf.add_paragraph() para.text = new_text # 删除多余段落（如果编辑后段落变少了） # python-pptx 不支持直接删除段落，只能清空 for i in range(len(edit_paras), len(existing_paras)): existing_paras[i].text = "" @shared_task(bind=True, name="insurance.regenerate_ppt", max_retries=3, default_retry_delay=30) def regenerate_ppt_task(self, task_id: str): """PPT 重新生成任务（基于编辑内容生成新版本）。""" if not _claim_task(task_id): logger.info(f"任务 {task_id} 已被领取或不在 queued 状态，跳过") return _update_task_status(task_id, stage="preparing", progress=5, message="准备重新生成") try: _execute_ppt_regenerate(task_id) except Exception as exc: logger.error(f"PPT 重新生成任务失败 [{task_id}]: {exc}", exc_info=True) _update_task_status(task_id, status="failed", error_code="regenerate_error", error_message=str(exc)[:1000], finished_at=datetime.now()) # 同步工作区状态 from insurance.models.generation_task import GenerationTask as _GT _task = _GT.query.get(task_id) if _task: from insurance.generation.task_service import sync_workspace_status sync_workspace_status(_task) raise def _execute_ppt_regenerate(task_id: str): """执行 PPT 重新生成：读取 DeckContract → 应用编辑 → 重新渲染。""" import os from insurance.db.compat import db from insurance.models.generation_task import GenerationTask from insurance.models.ppt_history import PptHistory from insurance.models.ppt_session import PptSession from insurance.ppt.renderer import PptRenderer task = GenerationTask.query.get(task_id) if not task: return session = PptSession.query.get(task.workspace_id) if not session: _update_task_status(task_id, status="failed", error_code="workspace_not_found", error_message="工作区不存在", finished_at=datetime.now()) return # 读取 DeckContract deck_path = session.deck_contract_path if not deck_path or not os.path.exists(deck_path): _update_task_status(task_id, status="failed", error_code="no_deck", error_message="DeckContract 快照不存在，请重新生成", finished_at=datetime.now()) return with open(deck_path, "r", encoding="utf-8") as f: deck = json.load(f) # 读取编辑数据 snapshot = json.loads(task.input_snapshot_json) if task.input_snapshot_json else {} edits = snapshot.get("edits") _update_task_status(task_id, stage="rendering", progress=30, message="重新渲染 PPT") # 使用 DeckContract 重新渲染 renderer = PptRenderer() user_id = task.user_id from insurance.config import get_storage_root output_dir = os.path.join(get_storage_root(), "outputs", "ppt", user_id, task_id) os.makedirs(output_dir, exist_ok=True) output_path = os.path.join(output_dir, "presentation.pptx") # 从 deck 中提取渲染参数 theme = deck.get("stylePreset", "broker") all_products = deck.get("products", []) normalized_data = all_products[0] if all_products else {} company_info = deck.get("company") template_config = deck.get("templateConfig") comparison = deck.get("comparison") generation_mode = deck.get("generationMode") scenario = deck.get("scenario") result = renderer.render_enhanced( normalized_data, output_path, theme=theme, company_info=company_info, template_config=template_config, all_products=all_products if len(all_products) > 1 else None, comparison=comparison, generation_mode=generation_mode, scenario=scenario, ) if not result.get("ok"): _update_task_status(task_id, status="failed", error_code="render_error", error_message=f"渲染失败: {result.get('error', '未知错误')}", finished_at=datetime.now()) return _update_task_status(task_id, stage="saving", progress=70, message="应用编辑") # 后处理：应用文字编辑和删除隐藏页 if edits and edits.get("slides"): try: _apply_edits_to_pptx(output_path, edits["slides"]) except Exception as exc: logger.warning("应用编辑到 PPTX 失败: %s", exc) _update_task_status(task_id, stage="saving", progress=80, message="保存新版本") # 解析幻灯片结构 slides_data = None slides_dir = os.path.join(output_dir, "slides") try: slides_result = renderer.parse_slides(output_path, slides_dir) if slides_result.get("ok"): with open(slides_result["jsonPath"], "r", encoding="utf-8") as _f: slides_data = json.load(_f) except Exception as exc: logger.warning("重新生成: 幻灯片解析失败: %s", exc) # 质量检查（传入 extractions 避免误判） quality_report = None try: from insurance.ppt.quality_checker import QualityChecker checker = QualityChecker() # 从 session 读取原始 extractions 用于关键数据检查 session_extractions = json.loads(session.extractions_json) if session.extractions_json else [] quality_report = checker.check( pptx_path=output_path, slides_data=slides_data, extractions=session_extractions, expected_slide_count=result.get("slideCount", 0), ) except Exception as exc: logger.warning("重新生成: 质量检查失败: %s", exc) # 保存 DeckContract 快照 new_deck_path = None if result.get("deck"): try: new_deck_path = os.path.join(output_dir, "deck_contract.json") with open(new_deck_path, "w", encoding="utf-8") as _f: json.dump(result["deck"], _f, ensure_ascii=False, indent=2) except Exception: pass # 更新会话 session = PptSession.query.get(task.workspace_id) if session: session.ppt_path = output_path session.slide_count = result.get("slideCount", 0) session.status = "done" session.generated_revision = session.draft_revision session.latest_output_path = output_path if slides_data: session.slides_json_path = os.path.join(slides_dir, "slides.json") session.preview_status = "ready" if quality_report: session.quality_report_json = json.dumps(quality_report, ensure_ascii=False) if new_deck_path: session.deck_contract_path = new_deck_path # 追加版本历史 versions = json.loads(session.versions_json) if session.versions_json else [] versions.append({ "revision": session.generated_revision, "path": output_path, "slidesJsonPath": os.path.join(slides_dir, "slides.json") if slides_data else None, "deckPath": new_deck_path, "slideCount": result.get("slideCount", 0), "createdAt": datetime.now().isoformat(), }) session.versions_json = json.dumps(versions, ensure_ascii=False) db.session.add(PptHistory( user_id=task.user_id, session_id=task.workspace_id, action_type="regenerate", content_snapshot=json.dumps({ "revision": session.generated_revision, "slideCount": result.get("slideCount", 0), }, ensure_ascii=False), file_url=output_path, )) db.session.commit() _update_task_status( task_id, status="done", stage="completed", progress=100, message="重新生成完成", finished_at=datetime.now(), output_json=json.dumps({ "downloadUrl": f"/insurance/workspace/tasks/{task_id}/download", "slideCount": result.get("slideCount", 0), "filePath": output_path, "revision": session.generated_revision if session else 0, }, ensure_ascii=False), ) # ─── 海报生成任务 ────────────────────────────────────────── @shared_task(bind=True, name="insurance.generate_poster", max_retries=3, default_retry_delay=30) def generate_poster_task(self, task_id: str): """海报图片生成任务。""" if not _claim_task(task_id): logger.info(f"任务 {task_id} 已被领取或不在 queued 状态，跳过") return _update_task_status(task_id, stage="preparing_data", progress=5, message="开始生成海报") try: _execute_poster_generate(task_id) except Exception as exc: logger.error(f"海报生成任务失败 [{task_id}]: {exc}", exc_info=True) _update_task_status(task_id, status="failed", error_code="generate_error", error_message=str(exc)[:1000], finished_at=datetime.now()) # 同步工作区状态 from insurance.models.generation_task import GenerationTask as _GT _task = _GT.query.get(task_id) if _task: from insurance.generation.task_service import sync_workspace_status sync_workspace_status(_task) raise def _execute_poster_generate(task_id: str): """执行海报生成逻辑。""" import os import re import uuid as uuid_mod from insurance.db.compat import db from insurance.models.generation_task import GenerationTask from insurance.models.poster_record import PosterRecord from insurance.models.poster_template_model import PosterTemplate from insurance.models.ppt_config import PptProduct, PptCompany def sync_poster_progress(progress: int, status: str = "pending", message: str = None): """同步进度到 PosterRecord，保证页面轮询海报记录时能看到真实进度。""" _record = PosterRecord.query.get(task.workspace_id) if _record: _record.task_status = status _record.task_progress = progress if message: _record.task_error = message if status == "failed" else None db.session.commit() task = GenerationTask.query.get(task_id) if not task: return record = PosterRecord.query.get(task.workspace_id) if not record: _update_task_status(task_id, status="failed", error_code="workspace_not_found", error_message="工作区不存在", finished_at=datetime.now()) return # 标记海报记录为运行中 record.task_status = "running" record.task_progress = 5 db.session.commit() snapshot = json.loads(task.input_snapshot_json) if task.input_snapshot_json else {} template_id = snapshot.get("templateId") product_id = snapshot.get("productId") copy_content = snapshot.get("copyContent", {}) size = snapshot.get("size", "1024x1792") reference_image = snapshot.get("referenceImage") use_masked_data = bool(snapshot.get("useMaskedData")) _update_task_status(task_id, stage="preparing_data", progress=20, message="准备数据") sync_poster_progress(20, "running") # 获取模板和产品信息 poster_template = PosterTemplate.query.get(template_id) if template_id else None product = PptProduct.query.get(product_id) if product_id else None company = PptCompany.query.get(product.company_id) if product else None if not reference_image and poster_template: reference_image = poster_template.reference_image # 脱敏处理 if use_masked_data: from insurance.ppt.masking import apply_product_mask, apply_company_mask, mask_text product_dict = product.to_dict() if product else None company_dict = company.to_dict() if company else None if product_dict: apply_product_mask(product_dict, True) if company_dict: apply_company_mask(company_dict, True) if product and company: real_name = product.display_name masked_name = (product_dict or {}).get("displayName", "") real_company = company.display_name masked_company = (company_dict or {}).get("displayName", "") replacements = {} if real_name and masked_name and real_name != masked_name: replacements[real_name] = masked_name if real_company and masked_company and real_company != masked_company: replacements[real_company] = masked_company if replacements: for key in copy_content: if isinstance(copy_content[key], str): copy_content[key] = mask_text(copy_content[key], replacements) else: product_dict = product.to_dict() if product else None company_dict = {"displayName": company.display_name} if company else None _update_task_status(task_id, stage="building_prompt", progress=40, message="构建 Prompt") sync_poster_progress(40, "running") # 加载产品小册子规则（含 features 来源页） product_rules = {} if product and product.manual_parsed_rules: try: product_rules = json.loads(product.manual_parsed_rules) except (json.JSONDecodeError, TypeError): logger.warning("产品规则 JSON 解析失败: product_id=%s", product_id) product_rules = {} # 用 content_builder 组装海报内容模块 from insurance.poster.content_builder import build_poster_content poster_content = build_poster_content( parsed_data={}, # Celery 任务不重新解析计划书，仅用小册子 product_rules=product_rules, output_mode=snapshot.get("outputMode", "single"), ) # 组装 prompt（传入小册子 features 用于风格参考） from insurance.poster.image_generator import PosterImageGenerator generator = PosterImageGenerator() prompt = generator.build_prompt( template=poster_template.to_dict() if poster_template else None, product=product_dict, company=company_dict, copy=copy_content, size=size, poster_content=poster_content, ) _update_task_status(task_id, stage="requesting_image", progress=60, message="请求图片生成") sync_poster_progress(60, "running") # 生成图片 generation_mode = "ai" provider_info = {} try: image_bytes, provider_info = generator.generate(prompt, size=size, reference_image=reference_image) except Exception as e: logger.warning(f"图片 API 失败，使用降级方案: {e}") from insurance.poster.image_generator import generate_fallback image_bytes = generate_fallback(copy_content, size=size) generation_mode = "fallback" _update_task_status(task_id, stage="saving", progress=85, message="保存文件") sync_poster_progress(85, "running") # 保存文件 from insurance.config import get_storage_root output_dir = os.path.join(get_storage_root(), "outputs", "posters", task_id) os.makedirs(output_dir, exist_ok=True) filename = f"poster.png" filepath = os.path.join(output_dir, filename) with open(filepath, "wb") as f: f.write(image_bytes) # 更新记录 record = PosterRecord.query.get(task.workspace_id) if record: record.export_url = filepath record.export_format = "png" record.generation_mode = generation_mode record.image_provider = provider_info.get("provider", "") record.image_model = provider_info.get("model", "") record.prompt_used = prompt[:2000] if prompt else None record.task_status = "done" record.task_progress = 100 record.finished_at = datetime.now() record.generated_revision = record.draft_revision db.session.commit() # 完成任务 _update_task_status( task_id, status="done", stage="completed", progress=100, message="生成完成", finished_at=datetime.now(), output_json=json.dumps({ "downloadUrl": f"/insurance/workspace/tasks/{task_id}/download", "filePath": filepath, }, ensure_ascii=False), ) # ─── 产品小册子解析任务 ────────────────────────────────────── MANUAL_PARSE_SOFT_TIMEOUT = 300 # 5 分钟软超时 MANUAL_PARSE_HARD_TIMEOUT = 360 # 6 分钟硬超时 @shared_task( bind=True, name="insurance.parse_product_manual", queue="insurance", soft_time_limit=MANUAL_PARSE_SOFT_TIMEOUT, time_limit=MANUAL_PARSE_HARD_TIMEOUT, ) def parse_product_manual_task(self, product_id: str): """产品小册子 PDF 解析任务（异步）。 流程：queued → parsing → parsed / failed """ from insurance.db.compat import db from insurance.models.ppt_config import PptProduct product = PptProduct.query.get(product_id) if not product: logger.error(f"小册子解析任务：产品 {product_id} 不存在") return # 状态检查：只处理 queued 状态 if product.manual_parse_status != "queued": logger.info(f"产品 {product_id} 当前状态 {product.manual_parse_status}，跳过") return # 更新为 parsing product.manual_parse_status = "parsing" product.manual_parse_message = "正在解析 PDF..." product.manual_parse_error = None product.manual_parse_started_at = datetime.now() product.manual_parse_finished_at = None db.session.commit() try: import asyncio import os from insurance.poster.manual_parser import parse_manual_pdf filepath = product.manual_file_url if not filepath or not os.path.exists(filepath): raise FileNotFoundError(f"小册子文件不存在: {filepath}") # 更新进度 product.manual_parse_message = "正在提取文本并调用 LLM..." db.session.commit() # 执行解析（同步调用异步函数） loop = asyncio.new_event_loop() try: result = loop.run_until_complete(parse_manual_pdf(filepath)) finally: loop.close() # 成功 product.manual_parsed_rules = json.dumps(result, ensure_ascii=False) product.manual_parse_status = "parsed" product.manual_parse_message = "解析完成" product.manual_parse_error = None product.manual_parse_finished_at = datetime.now() db.session.commit() logger.info(f"产品 {product_id} 小册子解析成功") except Exception as exc: error_msg = str(exc)[:1000] logger.error(f"产品 {product_id} 小册子解析失败: {exc}", exc_info=True) product.manual_parse_status = "failed" product.manual_parse_message = "解析失败" product.manual_parse_error = error_msg product.manual_parse_finished_at = datetime.now() db.session.commit() def recover_stale_manual_tasks(): """启动时恢复卡住的小册子解析任务。 将长时间停留在 queued/parsing 的记录标记为 failed。 应在应用启动时调用。 """ from insurance.db.compat import db from insurance.models.ppt_config import PptProduct timeout_minutes = 10 from datetime import timedelta cutoff = datetime.now() - timedelta(minutes=timeout_minutes) # 恢复卡在 parsing 的记录 stale_parsing = PptProduct.query.filter( PptProduct.manual_parse_status == "parsing", PptProduct.manual_parse_started_at < cutoff, ).all() for p in stale_parsing: p.manual_parse_status = "failed" p.manual_parse_error = "任务因服务重启而中断，请重新解析" p.manual_parse_finished_at = datetime.now() # 恢复长时间 queued 的记录 stale_queued = PptProduct.query.filter( PptProduct.manual_parse_status == "queued", PptProduct.updated_at < cutoff, ).all() for p in stale_queued: p.manual_parse_status = "failed" p.manual_parse_error = "任务排队超时，请重新解析" p.manual_parse_finished_at = datetime.now() if stale_parsing or stale_queued: db.session.commit() logger.info(f"已恢复 {len(stale_parsing)} 个解析过期任务, {len(stale_queued)} 个排队超时任务")