478 lines
14 KiB
Python
478 lines
14 KiB
Python
"""Web UI for managing recipients, manual send, and weekly scheduled send."""
|
||
|
||
import json
|
||
import os
|
||
import re
|
||
import subprocess
|
||
import sys
|
||
import threading
|
||
import time
|
||
from datetime import datetime, timedelta, timezone
|
||
from pathlib import Path
|
||
from typing import List
|
||
from zoneinfo import ZoneInfo
|
||
|
||
from dotenv import load_dotenv
|
||
from flask import Flask, flash, redirect, render_template, request, url_for
|
||
|
||
from email_sender import EmailSender
|
||
|
||
load_dotenv()
|
||
|
||
app = Flask(__name__)
|
||
app.config["SECRET_KEY"] = os.getenv("WEB_UI_SECRET_KEY", "dev-secret-key-change-in-env")
|
||
|
||
PROJECT_ROOT = Path(__file__).resolve().parent
|
||
DATA_DIR = Path(os.getenv("DATA_DIR", "./data")).resolve()
|
||
MANAGED_RECIPIENTS_FILE = Path(
|
||
os.getenv("RECIPIENTS_STORE_FILE", str(DATA_DIR / "managed_recipients.json"))
|
||
).resolve()
|
||
SCHEDULE_CONFIG_FILE = Path(
|
||
os.getenv("SCHEDULE_STORE_FILE", str(DATA_DIR / "scheduled_send_config.json"))
|
||
).resolve()
|
||
|
||
EMAIL_PATTERN = re.compile(r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$")
|
||
SCHEDULE_WEEKDAY_OPTIONS = [
|
||
(0, "星期一"),
|
||
(1, "星期二"),
|
||
(2, "星期三"),
|
||
(3, "星期四"),
|
||
(4, "星期五"),
|
||
(5, "星期六"),
|
||
(6, "星期日"),
|
||
]
|
||
SCHEDULE_DEFAULT = {
|
||
"enabled": False,
|
||
"weekday": 0,
|
||
"time": "09:00",
|
||
"subject": "",
|
||
"recipients": [],
|
||
"last_run_week": "",
|
||
}
|
||
|
||
_SCHEDULE_LOCK = threading.Lock()
|
||
_SCHEDULER_STARTED = False
|
||
|
||
|
||
def _ensure_data_dir() -> None:
|
||
DATA_DIR.mkdir(parents=True, exist_ok=True)
|
||
|
||
|
||
def _split_recipients(raw_text: str) -> List[str]:
|
||
if not raw_text:
|
||
return []
|
||
tokens = re.split(r"[,\n;，；\s]+", raw_text.strip())
|
||
return [item.strip() for item in tokens if item.strip()]
|
||
|
||
|
||
def _normalize_email(email: str) -> str:
|
||
return email.strip().lower()
|
||
|
||
|
||
def _dedupe_emails(items: List[str]) -> List[str]:
|
||
seen = set()
|
||
result = []
|
||
for raw in items:
|
||
item = _normalize_email(raw)
|
||
if item and item not in seen:
|
||
seen.add(item)
|
||
result.append(item)
|
||
return result
|
||
|
||
|
||
def _save_managed_recipients(items: List[str]) -> None:
|
||
_ensure_data_dir()
|
||
MANAGED_RECIPIENTS_FILE.write_text(
|
||
json.dumps(items, ensure_ascii=False, indent=2),
|
||
encoding="utf-8",
|
||
)
|
||
|
||
|
||
def get_managed_recipients() -> List[str]:
|
||
if MANAGED_RECIPIENTS_FILE.exists():
|
||
try:
|
||
payload = json.loads(MANAGED_RECIPIENTS_FILE.read_text(encoding="utf-8"))
|
||
if isinstance(payload, list):
|
||
recipients = _dedupe_emails([str(item) for item in payload])
|
||
valid = [x for x in recipients if EMAIL_PATTERN.match(x)]
|
||
if valid != recipients:
|
||
_save_managed_recipients(valid)
|
||
return valid
|
||
except Exception:
|
||
pass
|
||
|
||
seed = _dedupe_emails(_split_recipients(os.getenv("EMAIL_RECIPIENTS", "")))
|
||
valid_seed = [x for x in seed if EMAIL_PATTERN.match(x)]
|
||
if valid_seed:
|
||
_save_managed_recipients(valid_seed)
|
||
return valid_seed
|
||
|
||
|
||
def _normalize_weekly_schedule(payload: dict | None) -> dict:
|
||
data = dict(SCHEDULE_DEFAULT)
|
||
if isinstance(payload, dict):
|
||
data.update(payload)
|
||
|
||
data["enabled"] = bool(data.get("enabled", False))
|
||
|
||
weekday_raw = data.get("weekday", 0)
|
||
try:
|
||
weekday = int(weekday_raw)
|
||
except (TypeError, ValueError):
|
||
weekday = 0
|
||
data["weekday"] = min(max(weekday, 0), 6)
|
||
|
||
time_raw = str(data.get("time", "09:00")).strip()
|
||
if not re.match(r"^\d{2}:\d{2}$", time_raw):
|
||
time_raw = "09:00"
|
||
hour, minute = time_raw.split(":", 1)
|
||
hour_val = int(hour)
|
||
minute_val = int(minute)
|
||
if hour_val < 0 or hour_val > 23 or minute_val < 0 or minute_val > 59:
|
||
time_raw = "09:00"
|
||
data["time"] = time_raw
|
||
|
||
subject = str(data.get("subject", "")).strip()
|
||
data["subject"] = subject[:120]
|
||
|
||
recipients = data.get("recipients", [])
|
||
if not isinstance(recipients, list):
|
||
recipients = []
|
||
recipients = _dedupe_emails([str(item) for item in recipients])
|
||
recipients = [item for item in recipients if EMAIL_PATTERN.match(item)]
|
||
data["recipients"] = recipients
|
||
|
||
week_key = str(data.get("last_run_week", "")).strip()
|
||
if not re.match(r"^\d{4}-W\d{2}$", week_key):
|
||
week_key = ""
|
||
data["last_run_week"] = week_key
|
||
|
||
return data
|
||
|
||
|
||
def get_weekly_schedule_config() -> dict:
|
||
if not SCHEDULE_CONFIG_FILE.exists():
|
||
return dict(SCHEDULE_DEFAULT)
|
||
|
||
try:
|
||
payload = json.loads(SCHEDULE_CONFIG_FILE.read_text(encoding="utf-8"))
|
||
except Exception:
|
||
return dict(SCHEDULE_DEFAULT)
|
||
return _normalize_weekly_schedule(payload)
|
||
|
||
|
||
def save_weekly_schedule_config(schedule: dict) -> dict:
|
||
_ensure_data_dir()
|
||
normalized = _normalize_weekly_schedule(schedule)
|
||
with _SCHEDULE_LOCK:
|
||
SCHEDULE_CONFIG_FILE.write_text(
|
||
json.dumps(normalized, ensure_ascii=False, indent=2),
|
||
encoding="utf-8",
|
||
)
|
||
return normalized
|
||
|
||
|
||
def get_app_timezone() -> ZoneInfo:
|
||
tz_name = os.getenv("WEB_UI_TIMEZONE", "Asia/Shanghai").strip() or "Asia/Shanghai"
|
||
try:
|
||
return ZoneInfo(tz_name)
|
||
except Exception:
|
||
# Windows may lack IANA timezone data; fall back to fixed UTC+8.
|
||
return timezone(timedelta(hours=8), name="Asia/Shanghai")
|
||
|
||
|
||
def _current_week_key(now: datetime) -> str:
|
||
iso = now.isocalendar()
|
||
return f"{iso.year}-W{iso.week:02d}"
|
||
|
||
|
||
def run_full_refresh_and_generate_report() -> tuple[Path | None, str]:
|
||
max_news = os.getenv("WEB_UI_MAX_NEWS", "20")
|
||
wechat_count = os.getenv("WEB_UI_WECHAT_COUNT", "10")
|
||
baidu_count = os.getenv("WEB_UI_BAIDU_COUNT", "10")
|
||
ccgp_count = os.getenv("WEB_UI_CCGP_COUNT", "10")
|
||
ccgp_keywords = os.getenv("WEB_UI_CCGP_KEYWORDS", "").strip()
|
||
timeout_sec = int(os.getenv("WEB_UI_REFRESH_TIMEOUT_SEC", "1800"))
|
||
|
||
command = [
|
||
sys.executable,
|
||
"main.py",
|
||
"--mode",
|
||
"full",
|
||
"--sources",
|
||
"all",
|
||
"--max-news",
|
||
str(max_news),
|
||
"--wechat-count",
|
||
str(wechat_count),
|
||
"--baidu-count",
|
||
str(baidu_count),
|
||
"--ccgp-count",
|
||
str(ccgp_count),
|
||
]
|
||
if ccgp_keywords:
|
||
command.extend(["--ccgp-keywords", ccgp_keywords])
|
||
|
||
try:
|
||
process = subprocess.run(
|
||
command,
|
||
cwd=str(PROJECT_ROOT),
|
||
capture_output=True,
|
||
text=True,
|
||
encoding="utf-8",
|
||
errors="replace",
|
||
timeout=timeout_sec,
|
||
check=False,
|
||
)
|
||
except subprocess.TimeoutExpired:
|
||
return None, "Refresh and report generation timed out."
|
||
except Exception as exc:
|
||
return None, f"Refresh pipeline failed: {exc}"
|
||
|
||
if process.returncode != 0:
|
||
debug_text = (process.stderr or process.stdout or "").strip()
|
||
if len(debug_text) > 500:
|
||
debug_text = debug_text[-500:]
|
||
return None, f"Refresh/report failed (exit={process.returncode}). {debug_text}"
|
||
|
||
report_files = sorted(
|
||
[
|
||
path
|
||
for path in DATA_DIR.glob("report_*")
|
||
if path.is_file() and path.suffix.lower() in {".txt", ".md"}
|
||
],
|
||
key=lambda p: p.stat().st_mtime,
|
||
reverse=True,
|
||
)
|
||
if not report_files:
|
||
return None, "No report file found after refresh."
|
||
|
||
return report_files[0], ""
|
||
|
||
|
||
def send_report_with_refresh(recipients: List[str], subject: str | None = None) -> tuple[bool, str]:
|
||
sender = os.getenv("EMAIL_SENDER", "").strip()
|
||
sender_password = os.getenv("EMAIL_PASSWORD", "").strip()
|
||
if not sender or not sender_password:
|
||
return False, "EMAIL_SENDER or EMAIL_PASSWORD is missing."
|
||
|
||
if not recipients:
|
||
return False, "At least one recipient is required."
|
||
|
||
invalid = [item for item in recipients if not EMAIL_PATTERN.match(item)]
|
||
if invalid:
|
||
return False, f"Invalid recipient(s): {', '.join(invalid)}"
|
||
|
||
report_path, refresh_error = run_full_refresh_and_generate_report()
|
||
if not report_path:
|
||
return False, refresh_error or "No report generated."
|
||
|
||
email_sender = EmailSender(sender, sender_password)
|
||
success = email_sender.send_report(
|
||
recipient_emails=recipients,
|
||
report_path=str(report_path),
|
||
subject=subject,
|
||
)
|
||
if not success:
|
||
return False, "SMTP send failed."
|
||
return True, report_path.name
|
||
|
||
|
||
def _run_weekly_schedule_once() -> None:
|
||
schedule = get_weekly_schedule_config()
|
||
if not schedule.get("enabled"):
|
||
return
|
||
|
||
recipients = schedule.get("recipients", [])
|
||
if not recipients:
|
||
return
|
||
|
||
now = datetime.now(get_app_timezone())
|
||
if now.weekday() != int(schedule.get("weekday", 0)):
|
||
return
|
||
|
||
schedule_time = str(schedule.get("time", "09:00"))
|
||
try:
|
||
hour_str, minute_str = schedule_time.split(":", 1)
|
||
schedule_hour = int(hour_str)
|
||
schedule_minute = int(minute_str)
|
||
except Exception:
|
||
return
|
||
|
||
if now.hour != schedule_hour or now.minute != schedule_minute:
|
||
return
|
||
|
||
week_key = _current_week_key(now)
|
||
if schedule.get("last_run_week") == week_key:
|
||
return
|
||
|
||
ok, message = send_report_with_refresh(
|
||
recipients=recipients,
|
||
subject=schedule.get("subject") or None,
|
||
)
|
||
if ok:
|
||
schedule["last_run_week"] = week_key
|
||
save_weekly_schedule_config(schedule)
|
||
print(
|
||
f"[scheduler] Weekly send completed at {now.strftime('%Y-%m-%d %H:%M:%S')} "
|
||
f"for {len(recipients)} recipients, report={message}"
|
||
)
|
||
else:
|
||
print(f"[scheduler] Weekly send failed at {now.strftime('%Y-%m-%d %H:%M:%S')}: {message}")
|
||
|
||
|
||
def _scheduler_loop() -> None:
|
||
print("[scheduler] Weekly scheduler loop started.")
|
||
while True:
|
||
try:
|
||
_run_weekly_schedule_once()
|
||
except Exception as exc:
|
||
print(f"[scheduler] Unexpected error: {exc}")
|
||
time.sleep(30)
|
||
|
||
|
||
def start_scheduler_thread() -> None:
|
||
global _SCHEDULER_STARTED
|
||
if _SCHEDULER_STARTED:
|
||
return
|
||
thread = threading.Thread(target=_scheduler_loop, daemon=True, name="weekly-scheduler")
|
||
thread.start()
|
||
_SCHEDULER_STARTED = True
|
||
|
||
|
||
def is_scheduler_started() -> bool:
|
||
"""Return whether the background scheduler loop has started."""
|
||
return _SCHEDULER_STARTED
|
||
|
||
|
||
def mask_email(email: str) -> str:
|
||
if not email or "@" not in email:
|
||
return "未配置"
|
||
username, domain = email.split("@", 1)
|
||
if len(username) <= 2:
|
||
masked = username[0] + "*"
|
||
else:
|
||
masked = username[:2] + "*" * (len(username) - 2)
|
||
return f"{masked}@{domain}"
|
||
|
||
|
||
@app.route("/", methods=["GET"])
|
||
def index():
|
||
sender = os.getenv("EMAIL_SENDER", "").strip()
|
||
sender_password = os.getenv("EMAIL_PASSWORD", "").strip()
|
||
managed_recipients = get_managed_recipients()
|
||
schedule_config = get_weekly_schedule_config()
|
||
|
||
return render_template(
|
||
"email_console.html",
|
||
sender_masked=mask_email(sender),
|
||
sender_ready=bool(sender and sender_password),
|
||
managed_recipients=managed_recipients,
|
||
schedule_config=schedule_config,
|
||
schedule_weekday_options=SCHEDULE_WEEKDAY_OPTIONS,
|
||
scheduler_started=is_scheduler_started(),
|
||
)
|
||
|
||
|
||
@app.route("/send", methods=["POST"])
|
||
def send_email():
|
||
subject = request.form.get("subject", "").strip() or None
|
||
selected_managed = request.form.getlist("managed_recipients")
|
||
recipients = _dedupe_emails(selected_managed)
|
||
if not recipients:
|
||
flash("Please select at least one recipient.", "error")
|
||
return redirect(url_for("index"))
|
||
|
||
success, message = send_report_with_refresh(recipients=recipients, subject=subject)
|
||
if success:
|
||
flash(f"Sent successfully to {len(recipients)} recipient(s), report: {message}", "success")
|
||
else:
|
||
flash(f"Send failed: {message}", "error")
|
||
|
||
return redirect(url_for("index"))
|
||
|
||
|
||
@app.route("/schedule/update", methods=["POST"])
|
||
def update_schedule():
|
||
enabled = request.form.get("schedule_enabled") == "on"
|
||
subject = request.form.get("schedule_subject", "").strip()
|
||
weekday_raw = request.form.get("schedule_weekday", "0").strip()
|
||
time_raw = request.form.get("schedule_time", "09:00").strip()
|
||
recipients = get_managed_recipients()
|
||
|
||
try:
|
||
weekday = int(weekday_raw)
|
||
except ValueError:
|
||
weekday = 0
|
||
if weekday < 0 or weekday > 6:
|
||
weekday = 0
|
||
|
||
if not re.match(r"^\d{2}:\d{2}$", time_raw):
|
||
flash("Schedule time format should be HH:MM.", "error")
|
||
return redirect(url_for("index"))
|
||
|
||
if enabled and not recipients:
|
||
flash("Please add at least one managed recipient before enabling weekly schedule.", "error")
|
||
return redirect(url_for("index"))
|
||
|
||
current = get_weekly_schedule_config()
|
||
schedule = {
|
||
"enabled": enabled,
|
||
"weekday": weekday,
|
||
"time": time_raw,
|
||
"subject": subject[:120],
|
||
"recipients": recipients,
|
||
"last_run_week": current.get("last_run_week", ""),
|
||
}
|
||
save_weekly_schedule_config(schedule)
|
||
|
||
flash("Weekly schedule saved.", "success")
|
||
return redirect(url_for("index"))
|
||
|
||
|
||
@app.route("/recipients/add", methods=["POST"])
|
||
def add_recipient():
|
||
raw_email = request.form.get("new_recipient", "").strip()
|
||
if not raw_email:
|
||
flash("Please input a recipient email.", "error")
|
||
return redirect(url_for("index"))
|
||
|
||
email = _normalize_email(raw_email)
|
||
if not EMAIL_PATTERN.match(email):
|
||
flash("Invalid email format.", "error")
|
||
return redirect(url_for("index"))
|
||
|
||
recipients = get_managed_recipients()
|
||
if email in recipients:
|
||
flash("Recipient already exists.", "error")
|
||
return redirect(url_for("index"))
|
||
|
||
recipients.append(email)
|
||
_save_managed_recipients(recipients)
|
||
flash(f"Recipient added: {email}", "success")
|
||
return redirect(url_for("index"))
|
||
|
||
|
||
@app.route("/recipients/delete", methods=["POST"])
|
||
def delete_recipient():
|
||
raw_email = request.form.get("email", "").strip()
|
||
email = _normalize_email(raw_email)
|
||
recipients = get_managed_recipients()
|
||
|
||
if email not in recipients:
|
||
flash("Recipient not found.", "error")
|
||
return redirect(url_for("index"))
|
||
|
||
updated = [item for item in recipients if item != email]
|
||
_save_managed_recipients(updated)
|
||
flash(f"Recipient deleted: {email}", "success")
|
||
return redirect(url_for("index"))
|
||
|
||
|
||
if __name__ == "__main__":
|
||
host = os.getenv("WEB_UI_HOST", "127.0.0.1")
|
||
port = int(os.getenv("WEB_UI_PORT", "7860"))
|
||
debug = os.getenv("WEB_UI_DEBUG", "0") == "1"
|
||
|
||
app.run(host=host, port=port, debug=debug)
|