Update process_report.py

process_report.py

@@ -1,12 +1,10 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-process_report.py （增强版）
-与之前功能一致：读取 Excel -> 聚合 -> 生成 HTML + 附件 -> 通过 Resend（或 SMTP 回退）发送。
-主要增强：
- - 更鲁棒的表头匹配（中文/英文/缩写/常见子串）
- - 如果无法找到典型的分组键，会智能回退（选择前两个非数值列）并继续处理
- - 返回结果里包含警告信息，便于前端展示排查
+process_report.py
+读取最新或指定的“系统导出格式”Excel，按业务口径聚合为“邮件发送的格式”，
+并通过 Resend 发送邮件（HTML表格 + Excel附件）。
+新增：检测 Resend 返回中可能导致 Gmail 退信的错误信息，并在失败时可选通过 SMTP 回退发送（仅回退）。
 """
 
 import os
@@ -31,34 +29,37 @@ os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 RESEND_API_KEY = os.environ.get("RESEND_API_KEY")
 FROM_EMAIL = os.environ.get("FROM_EMAIL")
-FROM_NAME = os.environ.get("FROM_NAME")  # 可选，显示名
 TO_EMAIL = os.environ.get("TO_EMAIL")
 TIMEZONE = os.environ.get("TZ", "Asia/Shanghai")
 
-# SMTP 回退（可选）
+# ========== 新增（可选 SMTP 回退） ==========
+# 若希望在 Resend 失败（或怀疑被 Gmail 退信）时自动尝试通过 SMTP 发送，请在环境变量中配置：
+# SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASS
+# 例如：SMTP_HOST=smtp.gmail.com, SMTP_PORT=587, SMTP_USER=your@gmail.com, SMTP_PASS=your_app_password
 SMTP_HOST = os.environ.get("SMTP_HOST")
 SMTP_PORT = int(os.environ.get("SMTP_PORT", 587) or 587)
 SMTP_USER = os.environ.get("SMTP_USER")
 SMTP_PASS = os.environ.get("SMTP_PASS")
+# ===========================================
 
-# ====== 业务相关字段 & 语义关键词 ======
+# ====== 业务相关字段 ======
 ALIASES = {
-    "请购日期": ["请购日期", "请购日", "申请日期", "requisition date", "request date"],
-    "请购单号": ["请购单号", "请购单编号", "申请单号", "采购单号", "PO", "po", "po number", "order no", "order number"],
-    "物料编码": ["物料编码", "物料号", "物料代码", "item code", "sku", "item no", "material code"],
-    "物料名称": ["物料名称", "品名", "名称", "description", "item name"],
-    "纱支密度": ["纱支密度", "纱支", "yarn"],
-    "门幅(CM)": ["门幅（CM)", "门幅(CM)", "门幅cm", "门幅", "width", "幅宽"],
-    "颜色": ["颜色", "色号/颜色", "色号", "color"],
-    "主单位": ["主单位", "单位", "unit"],
-    "主数量": ["主数量", "数量", "请购数量", "qty", "quantity", "amount"],
-    "需求日期": ["需求日期", "需求日", "交期", "要求到货日期", "required date", "need date"],
-    "供应商": ["供应商", "供货商", "供应商名称", "vendor", "supplier"],
-    "到货日期": ["到货日期", "实到日期", "收货日期", "arrival date", "received date"],
-    "到货主数量": ["到货主数量", "到货数量", "实到数量", "received qty"],
-    "入库日期": ["入库日期", "入库日", "stockin date"],
-    "入库主数量": ["入库主数量", "入库数量", "stockin qty"],
-    "计划到货日期": ["计划到货日期", "预计到货日期", "承诺到货日期", "预计到货", "planned arrival"]
+    "请购日期": ["请购日期", "请购日", "申请日期"],
+    "请购单号": ["请购单号", "请购单编号", "申请单号"],
+    "物料编码": ["物料编码", "物料号", "物料代码"],
+    "物料名称": ["物料名称", "品名", "名称"],
+    "纱支密度": ["纱支密度", "纱支/密度", "纱支 密度"],
+    "门幅(CM)": ["门幅（CM)", "门幅(CM)", "门幅cm", "门幅"],
+    "颜色": ["颜色", "色号/颜色", "色号"],
+    "主单位": ["主单位", "单位"],
+    "主数量": ["主数量", "数量", "请购数量"],
+    "需求日期": ["需求日期", "需求日", "交期", "要求到货日期"],
+    "供应商": ["供应商", "供货商", "供应商名称"],
+    "到货日期": ["到货日期", "实到日期", "收货日期"],
+    "到货主数量": ["到货主数量", "到货数量", "实到数量"],
+    "入库日期": ["入库日期", "入库日"],
+    "入库主数量": ["入库主数量", "入库数量"],
+    "计划到货日期": ["计划到货日期", "预计到货日期", "承诺到货日期", "计划到货日"],
 }
 
 EMAIL_COLS_DEFAULT = [
@@ -66,64 +67,28 @@ EMAIL_COLS_DEFAULT = [
     "主数量","需求日期","供应商","到货日期","到货主数量","入库日期","入库主数量","目前进度"
 ]
 
+TEMPLATE_CANDIDATES = [
+    "/workspace/邮件发送的格式.xlsx",
+    "/workspace/templates/邮件发送的格式.xlsx",
+    "/app/邮件发送的格式.xlsx",
+    "/app/templates/邮件发送的格式.xlsx",
+]
+
+
 # ====== 工具函数 ======
 def _today() -> date:
     return datetime.now().date()
 
-def _clean_col(c: str) -> str:
-    if c is None:
-        return ""
-    return str(c).strip().replace('\ufeff', '').replace('\u200b', '')
-
 def _normalize_columns(df: pd.DataFrame) -> pd.DataFrame:
-    """
-    使用 ALIASES 做尽可能多的列名匹配；若未匹配上，再做基于子串的小/英文匹配；
-    返回重命名后的 df 与已匹配的 mapping 列表（便于调试/返回警告）。
-    """
-    mapping = {}
-    matched = {}
-    cols = [c for c in df.columns]
-    cleaned = {c: _clean_col(c) for c in cols}
-
-    # 先基于完全匹配（包括 ALIASES 列表）
+    mapped = {}
     for std_name, variants in ALIASES.items():
-        for orig_col, c_clean in cleaned.items():
-            if orig_col in mapping:
-                continue
-            for v in variants:
-                if c_clean.lower() == str(v).lower():
-                    mapping[orig_col] = std_name
-                    matched[orig_col] = std_name
-                    break
-            if orig_col in mapping:
+        for v in df.columns:
+            v_clean = str(v).strip()
+            if v_clean in variants:
+                mapped[v] = std_name
                 break
-
-    # 次之基于子串匹配（包含关键字）
-    keyword_map = {
-        "请购单号": ["po", "order", "请购", "采购单"],
-        "物料编码": ["sku", "物料", "item code", "itemno", "item no", "物料号", "料号"],
-        "物料名称": ["品名", "物料名称", "description", "item name", "名称"],
-        "主数量": ["数量", "qty", "数量(米)", "amount"],
-        "供应商": ["供应商", "vendor", "supplier"],
-        "需求日期": ["需求", "required", "need date", "交期"],
-        "到货日期": ["到货", "arrival", "received"],
-        "请购日期": ["请购日期", "request", "requisition"]
-    }
-    for orig_col, c_clean in cleaned.items():
-        if orig_col in mapping:
-            continue
-        low = c_clean.lower()
-        for std, keys in keyword_map.items():
-            for k in keys:
-                if k in low:
-                    mapping[orig_col] = std
-                    matched[orig_col] = std
-                    break
-            if orig_col in mapping:
-                break
-
-    df = df.rename(columns=mapping)
-    return df, matched
+    df = df.rename(columns=mapped)
+    return df
 
 def _find_header_row(path: str, must_have: List[str] = None, try_rows: int = 10) -> int:
     must_have = must_have or ["物料编码", "主数量"]
@@ -132,18 +97,12 @@ def _find_header_row(path: str, must_have: List[str] = None, try_rows: int = 10)
             df_try = pd.read_excel(path, header=r, nrows=1)
         except Exception:
             continue
-        cols = [ _clean_col(c) for c in df_try.columns ]
-        lowcols = [c.lower() for c in cols]
-        ok = False
-        for m in must_have:
-            mm = m.lower()
-            if any(mm in c for c in lowcols) or any(c == mm for c in lowcols):
-                ok = True
-        if ok:
+        cols = [str(c).strip() for c in df_try.columns]
+        if all(any(m in c for c in cols) or m in cols for m in must_have):
             return r
     return 0
 
-def read_system_export(path: str) -> Tuple[pd.DataFrame, List[str]]:
+def read_system_export(path: str) -> pd.DataFrame:
     header_row = _find_header_row(path)
     try:
         df = pd.read_excel(path, header=header_row)
@@ -151,77 +110,39 @@ def read_system_export(path: str) -> Tuple[pd.DataFrame, List[str]]:
         df = pd.read_excel(path, header=0)
 
     df = df.dropna(axis=1, how="all")
-    df.columns = [_clean_col(c) for c in df.columns]
-
-    df, matched = _normalize_columns(df)
+    df = _normalize_columns(df)
 
-    # 基本清洗
     if "物料名称" in df.columns:
         df["物料名称"] = df["物料名称"].astype(str).fillna('')
-        contains_e = df["物料名称"].str.contains("鹅", na=False)
-        contains_ya = df["物料名称"].str.contains("鸭", na=False)
-        contains_huazhu = df["物料名称"].str.contains("华住", na=False)
-        contains_huazhu_special = df["物料名称"].str.contains("华住专用", na=False)
+        contains_e = df["物料名称"].str.contains("鹅")
+        contains_ya = df["物料名称"].str.contains("鸭")
+        contains_huazhu = df["物料名称"].str.contains("华住")
+        contains_huazhu_special = df["物料名称"].str.contains("华住专用")
         to_remove = (contains_e | contains_ya | contains_huazhu) & ~contains_huazhu_special
-        if to_remove.any():
-            df = df[~to_remove]
+        df = df[~to_remove]
 
     for c in ["请购日期","需求日期","到货日期","入库日期","计划到货日期"]:
         if c in df.columns:
             df[c] = pd.to_datetime(df[c], errors="coerce")
-
+            
     for c in ["主数量","到货主数量","入库主数量"]:
         if c in df.columns:
             df[c] = pd.to_numeric(df[c], errors="coerce").fillna(0)
 
     df = df.dropna(how="all")
-    return df, list(matched.items())
+    return df
 
 def _first_nonnull(series: pd.Series):
     return series.dropna().iloc[0] if not series.dropna().empty else None
 
-def _infer_group_keys(df: pd.DataFrame) -> Tuple[List[str], List[str]]:
-    """
-    尝试推断用于 group by 的列：
-    1) 优先使用已命名的标准字段（请购单号、物料编码、物料名称、供应商 等）
-    2) 若找不到，回退为：选择前两个非数值列（通常是编号/名称）
-    返回 (group_keys, warnings)
-    """
-    std_candidates = ["请购单号","物料编码","物料名称","供应商"]
-    present = [c for c in std_candidates if c in df.columns]
-    warnings = []
-    if present:
-        # 至少保留物料编码或请购单号其一，若缺一则用其他字段补足
-        return present, warnings
-
-    # 尝试通过列名中包含关键词来识别（更宽松）
-    lowered = {c: c.lower() for c in df.columns}
-    found = []
-    for c in df.columns:
-        low = c.lower()
-        if any(k in low for k in ["po", "order", "请购", "采购"]):
-            found.append(c)
-        elif any(k in low for k in ["物料", "sku", "item", "料号", "code"]):
-            found.append(c)
-        if len(found) >= 2:
-            break
-    if found:
-        warnings.append(f"通过关键词推断分组字段: {found}")
-        return found, warnings
-
-    # 最后一招：挑选前两个非数值列作为分组键
-    non_numeric = [c for c in df.columns if df[c].dtype == object or pd.api.types.is_string_dtype(df[c])]
-    fallback = non_numeric[:2] if len(non_numeric) >= 2 else list(df.columns[:2])
-    warnings.append(f"未找到标准分组字段，采用回退列作为分组键: {fallback}")
-    return fallback, warnings
-
-def aggregate_for_email(df: pd.DataFrame) -> Tuple[pd.DataFrame, List[str]]:
-    group_keys, warnings = _infer_group_keys(df)
+def aggregate_for_email(df: pd.DataFrame) -> pd.DataFrame:
+    group_keys = [k for k in [
+        "请购单号","物料编码","物料名称","纱支密度","门幅(CM)","颜色","主单位","供应商"
+    ] if k in df.columns]
+
     if not group_keys:
-        # 这通常不会发生，因为 _infer_group_keys 会回退
-        raise RuntimeError("无法推断分组键，请检查输入表头。")
+        raise RuntimeError("找不到用于分组的关键字段（如 请购单号/物料编码 等），请检查导入的表头。")
 
-    # 构造 agg map
     agg_map = {
         "主数量": _first_nonnull,
         "请购日期": _first_nonnull,
@@ -232,19 +153,12 @@ def aggregate_for_email(df: pd.DataFrame) -> Tuple[pd.DataFrame, List[str]]:
         "到货主数量": "sum",
         "入库主数量": "sum"
     }
+    
     final_agg_map = {k: v for k, v in agg_map.items() if k in df.columns}
 
-    # 防护：如果 group_keys 中包含不存在的列，过滤掉
-    group_keys = [g for g in group_keys if g in df.columns]
-    if not group_keys:
-        # 拜托使用第一列作为最低限度分组（保证不崩溃）
-        first_col = df.columns[0]
-        warnings.append(f"最终找不到任何已识别的分组字段，强制使用第一列 `{first_col}` 作为分组键。")
-        group_keys = [first_col]
-
     grouped = df.groupby(group_keys, dropna=False).agg(final_agg_map).reset_index()
     grouped["目前进度"] = grouped.apply(_calc_progress_row, axis=1)
-
+    
     def get_sort_key(status_text):
         if "逾期" in status_text and "未到货" in status_text:
             return 1
@@ -258,19 +172,19 @@ def aggregate_for_email(df: pd.DataFrame) -> Tuple[pd.DataFrame, List[str]]:
 
     grouped['sort_key'] = grouped['目前进度'].apply(get_sort_key)
     grouped = grouped.sort_values(by='sort_key').drop(columns=['sort_key'])
-
+    
     if "计划到货日期" in grouped.columns:
         grouped = grouped.drop(columns=["计划到货日期"])
 
     final_cols = [col for col in EMAIL_COLS_DEFAULT if col in grouped.columns]
-    final = grouped[final_cols] if final_cols else grouped
+    final = grouped[final_cols]
 
     date_cols_to_format = ["请购日期", "需求日期", "到货日期", "入库日期"]
     for col in date_cols_to_format:
         if col in final.columns:
             final[col] = pd.to_datetime(final[col], errors='coerce').dt.strftime('%Y-%m-%d')
 
-    return final, warnings
+    return final
 
 def _calc_progress_row(row: pd.Series) -> str:
     today = pd.Timestamp(_today())
@@ -285,7 +199,7 @@ def _calc_progress_row(row: pd.Series) -> str:
 
     parts: List[str] = []
     shortage = max(0.0, main_qty - arr_qty)
-
+    
     if arr_qty > 0:
         parts.append(f"部分到货 缺货{shortage:g}米")
     elif pd.isna(arrival_date) or arr_qty == 0:
@@ -297,18 +211,15 @@ def _calc_progress_row(row: pd.Series) -> str:
             parts.append(f"已逾期{overdue_days}天")
 
     if pd.notna(plan_arrival):
-        try:
-            days_ahead = (pd.to_datetime(plan_arrival).date() - today.date()).days
-            if 0 <= days_ahead <= 7:
-                parts.append(f"未来7天到货（计划{str(plan_arrival)[:10]}）")
-        except Exception:
-            pass
-
+        days_ahead = (plan_arrival.date() - today.date()).days
+        if 0 <= days_ahead <= 7:
+            parts.append(f"未来7天到货（计划{str(plan_arrival.date())}）")
+    
     if not parts:
         if pd.notna(demand_date) and today <= pd.Timestamp(demand_date.date()):
             return "未到货（未到期）"
         return "处理中"
-
+        
     return "；".join(parts)
 
 def _find_latest_input(input_dir: str) -> Optional[str]:
@@ -323,13 +234,13 @@ def _find_latest_input(input_dir: str) -> Optional[str]:
 def _df_to_styled_excel_bytes(df: pd.DataFrame) -> bytes:
     bio = BytesIO()
     writer = pd.ExcelWriter(bio, engine='xlsxwriter')
-
+    
     sheet_name = '采购执行表'
     df.fillna('').to_excel(writer, sheet_name=sheet_name, index=False)
-
+    
     workbook = writer.book
     worksheet = writer.sheets[sheet_name]
-
+    
     header_format = workbook.add_format({'bold': True, 'font_name': 'Arial', 'font_size': 10, 'border': 1, 'align': 'center', 'valign': 'vcenter'})
     default_format = workbook.add_format({'font_name': 'Arial', 'font_size': 10, 'border': 1})
     overdue_format = workbook.add_format({'font_name': 'Arial', 'font_size': 10, 'border': 1, 'font_color': 'red'})
@@ -338,7 +249,7 @@ def _df_to_styled_excel_bytes(df: pd.DataFrame) -> bytes:
         worksheet.write(0, col_num, value, header_format)
 
     worksheet.conditional_format(1, 0, len(df), len(df.columns)-1, {'type': 'no_blanks', 'format': default_format})
-
+    
     try:
         progress_col_idx = df.columns.get_loc('目前进度')
         for row_num in range(len(df)):
@@ -350,9 +261,9 @@ def _df_to_styled_excel_bytes(df: pd.DataFrame) -> bytes:
 
     for i, col in enumerate(df.columns):
         column_len = df[col].astype(str).str.len().max()
-        column_len = max(column_len, len(col) * 2)
-        worksheet.set_column(i, i, min(column_len, 40))
-
+        column_len = max(column_len, len(col) * 2) 
+        worksheet.set_column(i, i, min(column_len, 40)) 
+        
     writer.close()
     bio.seek(0)
     return bio.read()
@@ -368,55 +279,71 @@ def _build_html_body(df: pd.DataFrame, title: str) -> str:
     </body></html>"""
     return html
 
+# ====== 增强的 Resend 发送函数（最小修改） ======
 def _send_email_via_resend(subject: str, html_body: str, attachment_bytes: Optional[bytes], attachment_name: str) -> Tuple[bool, str]:
+    """
+    使用 Resend API 发送邮件（带附件 base64）。
+    如果 Resend 返回错误，并且怀疑为 Gmail 退信/被阻止，会把详细信息放入返回字符串中。
+    """
     if not (RESEND_API_KEY and FROM_EMAIL and TO_EMAIL):
         return False, "缺少 Resend 配置（RESEND_API_KEY / FROM_EMAIL / TO_EMAIL）"
-
-    if FROM_NAME:
-        from_field = f"{FROM_NAME} <{FROM_EMAIL}>"
-    else:
-        from_field = FROM_EMAIL
-
+    
     url = "https://api.resend.com/emails"
-    headers = {
-        "Authorization": f"Bearer {RESEND_API_KEY}",
-        "Content-Type": "application/json"
-    }
-
-    payload = {
-        "from": from_field,
-        "to": [TO_EMAIL],
-        "subject": subject,
-        "html": html_body,
-        "headers": {"Reply-To": FROM_EMAIL, "Sender": FROM_EMAIL}
-    }
-
+    headers = {"Authorization": f"Bearer {RESEND_API_KEY}", "Content-Type": "application/json"}
+    
+    # 尽量把 From 用标准格式传过去（某些邮件网关更容易接受 Name <email>）
+    from_field = FROM_EMAIL
+    if "FROM_NAME" in os.environ and os.environ.get("FROM_NAME"):
+        from_field = f"{os.environ.get('FROM_NAME')} <{FROM_EMAIL}>"
+    
+    payload = {"from": from_field, "to": [TO_EMAIL], "subject": subject, "html": html_body}
     if attachment_bytes is not None:
-        payload["attachments"] = [
-            {"filename": attachment_name, "content": base64.b64encode(attachment_bytes).decode("utf-8")}
-        ]
-
+        payload["attachments"] = [{"filename": attachment_name, "content": base64.b64encode(attachment_bytes).decode("utf-8")}]
+    
     try:
+        # 保留原有行为：请求 Resend
         resp = requests.post(url, headers=headers, data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), timeout=30)
-        if resp.status_code >= 200 and resp.status_code < 300:
-            return True, f"Resend OK: {resp.text}"
-        else:
-            return False, f"Resend 返回失败状态 {resp.status_code}: {resp.text}"
+        # 判断 success
+        if 200 <= resp.status_code < 300:
+            return True, resp.text
+        # 非 2xx -> 视为失败，解析可能的退信/拒收信息
+        resp_text = ""
+        try:
+            resp_text = resp.text
+        except Exception:
+            resp_text = repr(resp.content)
+        # 检查常见 Gmail/退信关键词（简单检测）
+        lowered = resp_text.lower()
+        gmail_related = any(k in lowered for k in [
+            "550", "5.1.1", "user unknown", "mailbox unavailable", "message rejected", "delivery failed", "mailbox not found",
+            "gmail", "google", "suppression", "bounce", "blocked", "denied"
+        ])
+        extra = ""
+        if gmail_related:
+            extra = "；怀疑为 Gmail/目标邮箱���信或被阻断（响应中包含疑似退信/阻断关键词）。"
+            extra += " 请检查 Resend 控制台的 Suppression、发件人验证（SPF/DKIM），以及邮件退回通知（Mail Delivery Subsystem）。"
+        return False, f"Resend 返回失败状态 {resp.status_code}: {resp_text}{extra}"
     except requests.exceptions.RequestException as e:
         return False, f"邮件发送请求失败: {e}"
 
+# ====== 新增：SMTP 回退实现（不会默认使用，仅在 Resend 失败且环境定义了 SMTP 配置时尝试） ======
 def _send_email_via_smtp(subject: str, html_body: str, attachment_bytes: Optional[bytes], attachment_name: str) -> Tuple[bool, str]:
+    """
+    可选的 SMTP 回退。需要在环境变量中配置 SMTP_HOST/SMTP_PORT/SMTP_USER/SMTP_PASS。
+    这一步仅作为回退，不改变你原有首选的 Resend 逻辑。
+    """
     if not (SMTP_HOST and SMTP_USER and SMTP_PASS and FROM_EMAIL and TO_EMAIL):
         return False, "缺少 SMTP 配置（SMTP_HOST / SMTP_USER / SMTP_PASS / FROM_EMAIL / TO_EMAIL）"
 
     try:
         msg = EmailMessage()
-        sender = f"{FROM_NAME} <{FROM_EMAIL}>" if FROM_NAME else FROM_EMAIL
+        sender = FROM_EMAIL
+        if "FROM_NAME" in os.environ and os.environ.get("FROM_NAME"):
+            sender = f"{os.environ.get('FROM_NAME')} <{FROM_EMAIL}>"
         msg["From"] = sender
         msg["To"] = TO_EMAIL
         msg["Subject"] = subject
-        msg["Reply-To"] = FROM_EMAIL
-        msg.set_content("这是 HTML 邮件，请在支持 HTML 的客户端查看。")
+        msg.set_content("这是 HTML 邮件（备用 SMTP 发送），请使用支持 HTML 的邮件客户端查看。")
         msg.add_alternative(html_body, subtype='html')
 
         if attachment_bytes is not None:
@@ -427,11 +354,11 @@ def _send_email_via_smtp(subject: str, html_body: str, attachment_bytes: Optiona
         smtp.login(SMTP_USER, SMTP_PASS)
         smtp.send_message(msg)
         smtp.quit()
-        return True, "SMTP 发送成功"
+        return True, "SMTP 发送成功（作为回退）"
     except Exception as e:
-        return False, f"SMTP 发送失败: {e}"
+        return False, f"SMTP 发送失败（回退）: {e}"
 
-# ====== 主流程 ======
+# ====== 主流程（保持原有流程不变，仅在发送失败时尝试回退） ======
 def run_once(file_path: Optional[str] = None) -> dict:
     try:
         if file_path is None:
@@ -439,35 +366,29 @@ def run_once(file_path: Optional[str] = None) -> dict:
             if not file_path:
                 return {"ok": False, "msg": f"未在 {INPUT_DIR} 找到Excel输入文件"}
 
-        raw, matched = read_system_export(file_path)
-        final, warnings = aggregate_for_email(raw)
-        # 合并 matched/warnings 到返回信息，便于定位表头差异
-        combined_warnings = []
-        if matched:
-            combined_warnings.append(f"匹配到的列映射: {matched}")
-        if warnings:
-            combined_warnings.extend(warnings)
-
+        raw = read_system_export(file_path)
+        final = aggregate_for_email(raw)
+        
         out_name = f"邮件发送的格式_{datetime.now().strftime('%Y%m%d')}.xlsx"
         out_path = os.path.join(OUTPUT_DIR, out_name)
-
+        
         attach = _df_to_styled_excel_bytes(final)
         final.to_excel(out_path, index=False)
 
         subject = f"采购执行表自动推送 {datetime.now().date()}"
         html = _build_html_body(final, title=f"采购执行表（{datetime.now().date()}）")
-
         ok, info = _send_email_via_resend(subject, html, attachment_bytes=attach, attachment_name=out_name)
 
+        # 如果 Resend 失败，且配置了 SMTP 回退，则尝试通过 SMTP 重发（仅回退）
         if not ok and SMTP_HOST and SMTP_USER and SMTP_PASS:
             ok_smtp, info_smtp = _send_email_via_smtp(subject, html, attachment_bytes=attach, attachment_name=out_name)
             if ok_smtp:
-                return {"ok": True, "msg": "通过 SMTP 回退发送成功", "input": file_path, "output": out_path, "rows": len(final), "resend_info": info, "smtp_info": info_smtp, "warnings": combined_warnings}
+                return {"ok": True, "msg": "Resend 失败，但通过 SMTP 回退发送成功", "input": file_path, "output": out_path, "rows": len(final), "resend_info": info, "smtp_info": info_smtp}
             else:
-                return {"ok": False, "msg": f"Resend 失败: {info}；SMTP 回退也失败: {info_smtp}", "input": file_path, "output": out_path, "rows": len(final), "warnings": combined_warnings}
-
-        return {"ok": ok, "msg": "邮件发送成功" if ok else f"邮件发送失败：{info}", "input": file_path, "output": out_path, "rows": len(final), "warnings": combined_warnings}
-
+                return {"ok": False, "msg": f"Resend 失败: {info}；SMTP 回退也失败: {info_smtp}", "input": file_path, "output": out_path, "rows": len(final)}
+        
+        return {"ok": ok, "msg": "邮件发送成功" if ok else f"邮件发送失败：{info}", "input": file_path, "output": out_path, "rows": len(final)}
+    
     except Exception as e:
         import traceback
         return {"ok": False, "msg": f"处理文件时发生严重错误: {e}", "traceback": traceback.format_exc()}
@@ -476,7 +397,7 @@ def main():
     arg_file = sys.argv[1] if len(sys.argv) > 1 else None
     result = run_once(arg_file)
     print(json.dumps(result, ensure_ascii=False))
-
+    
     if not result.get("ok"):
         sys.exit(1)