444 lines
17 KiB
Python
444 lines
17 KiB
Python
"""Finance service — daily revenue vs cost reconciliation.
|
|
|
|
Architecture:
|
|
- Website revenue: Sub2ApiWebsiteClient._request("/usage/stats", params=...)
|
|
Reuses all existing error handling, logging, auth (api_key / bearer).
|
|
- Upstream cost (Sub2API): UpstreamClient._send_request(url, params=...)
|
|
within the client context — retains cookies, 401 refresh, external API log.
|
|
- Upstream cost (New-API/Nox-API): same UpstreamClient pattern.
|
|
|
|
New service functions (get_or_create_daily_summary, compute_daily_summary,
|
|
overwrite_daily_summary) wrap get_daily_summary with DB-backed snapshot storage.
|
|
Each item fails independently; failures do NOT contribute to totals, and the UI
|
|
must treat any failed item as incomplete accounting data.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
from datetime import date, datetime, timedelta, timezone
|
|
from typing import Any
|
|
|
|
import pytz
|
|
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.models.upstream import Upstream
|
|
from app.models.website import Website
|
|
from app.services.upstream_client import UpstreamClient
|
|
from app.services.website_client import Sub2ApiWebsiteClient, WebsiteError
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
SHANGHAI_TZ = pytz.timezone("Asia/Shanghai")
|
|
|
|
|
|
# ─────────────────────────────────────────────
|
|
# Upstream type classification
|
|
# ─────────────────────────────────────────────
|
|
|
|
def classify_upstream(upstream: Upstream) -> str:
|
|
"""Return 'sub2api' | 'new_api' | 'unknown'."""
|
|
prefix = (upstream.api_prefix or "").strip("/")
|
|
if prefix == "api/v1":
|
|
return "sub2api"
|
|
auth = upstream.auth_type or ""
|
|
if auth in ("new_api_token", "nox_token"):
|
|
return "new_api"
|
|
if auth in ("cookie", "login_password"):
|
|
try:
|
|
cfg = json.loads(upstream.auth_config_json or "{}")
|
|
except Exception:
|
|
cfg = {}
|
|
if (
|
|
prefix == ""
|
|
and (
|
|
auth == "cookie"
|
|
or "/api/user/login" in (cfg.get("login_path") or "")
|
|
or cfg.get("provider") in {"new-api", "nox-api"}
|
|
)
|
|
):
|
|
return "new_api"
|
|
return "unknown"
|
|
|
|
|
|
# ─────────────────────────────────────────────
|
|
# Date helpers
|
|
# ─────────────────────────────────────────────
|
|
|
|
def yesterday_shanghai() -> date:
|
|
return datetime.now(SHANGHAI_TZ).date() - timedelta(days=1)
|
|
|
|
|
|
def today_shanghai() -> date:
|
|
return datetime.now(SHANGHAI_TZ).date()
|
|
|
|
|
|
def date_to_shanghai_timestamps(d: date) -> tuple[int, int]:
|
|
"""Return (start_unix, end_unix) for 00:00:00..23:59:59 Asia/Shanghai on date d."""
|
|
start = SHANGHAI_TZ.localize(datetime(d.year, d.month, d.day, 0, 0, 0))
|
|
end = SHANGHAI_TZ.localize(datetime(d.year, d.month, d.day, 23, 59, 59))
|
|
return int(start.timestamp()), int(end.timestamp())
|
|
|
|
|
|
# ─────────────────────────────────────────────
|
|
# Website revenue
|
|
# ─────────────────────────────────────────────
|
|
|
|
def fetch_website_revenue(website: Website, target_date: date) -> tuple[float, str | None]:
|
|
"""Fetch website revenue for target_date.
|
|
|
|
Uses Sub2ApiWebsiteClient (existing auth, error handling, external API log).
|
|
GET /usage/stats?start_date=...&end_date=...&timezone=Asia/Shanghai&nocache=true
|
|
"""
|
|
date_str = target_date.isoformat()
|
|
try:
|
|
with Sub2ApiWebsiteClient(
|
|
base_url=website.base_url,
|
|
api_prefix=website.api_prefix,
|
|
auth_type=website.auth_type,
|
|
auth_config=json.loads(website.auth_config_json or "{}"),
|
|
timeout=float(website.timeout_seconds),
|
|
target_id=website.id,
|
|
target_name=website.name,
|
|
) as c:
|
|
data = c._request(
|
|
"GET",
|
|
"/usage/stats",
|
|
params={
|
|
"start_date": date_str,
|
|
"end_date": date_str,
|
|
"timezone": "Asia/Shanghai",
|
|
"nocache": "true",
|
|
},
|
|
)
|
|
# Sub2API wraps payload in `data` key: {data: {total_actual_cost: ...}}
|
|
payload = data.get("data", data) if isinstance(data, dict) else {}
|
|
if isinstance(payload, dict):
|
|
cost = payload.get("total_actual_cost")
|
|
if cost is not None:
|
|
return float(cost), None
|
|
return 0.0, "响应中找不到 total_actual_cost 字段"
|
|
except WebsiteError as e:
|
|
return 0.0, str(e)
|
|
except Exception as e:
|
|
return 0.0, str(e)
|
|
|
|
|
|
# ─────────────────────────────────────────────
|
|
# Upstream cost — Sub2API
|
|
# ─────────────────────────────────────────────
|
|
|
|
def fetch_upstream_cost_sub2api(upstream: Upstream, target_date: date) -> tuple[float, str | None]:
|
|
"""Fetch cost for Sub2API-type upstream via /usage/stats (user-facing endpoint).
|
|
|
|
Calls UpstreamClient._send_request inside the context so that cookies,
|
|
401 refresh, and external API logging are all preserved.
|
|
|
|
Sub2API's end_date is exclusive (+1 day internally), so passing the same
|
|
date for start and end yields the full day's data.
|
|
"""
|
|
date_str = target_date.isoformat()
|
|
auth_config = json.loads(upstream.auth_config_json or "{}")
|
|
try:
|
|
with UpstreamClient(
|
|
base_url=upstream.base_url,
|
|
api_prefix=upstream.api_prefix,
|
|
auth_type=upstream.auth_type,
|
|
auth_config=auth_config,
|
|
timeout=float(upstream.timeout_seconds),
|
|
on_auth_config_update=lambda _: None, # read-only, no DB write
|
|
target_id=upstream.id,
|
|
target_name=upstream.name,
|
|
) as client:
|
|
client.ensure_authenticated()
|
|
params = {
|
|
"start_date": date_str,
|
|
"end_date": date_str,
|
|
"timezone": "Asia/Shanghai",
|
|
}
|
|
resp = client._send_request("GET", client._url("/usage/stats"), params=params)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
payload = data.get("data", data) if isinstance(data, dict) else {}
|
|
if isinstance(payload, dict):
|
|
cost = payload.get("total_actual_cost")
|
|
if cost is not None:
|
|
return float(cost), None
|
|
return 0.0, "响应中找不到 total_actual_cost 字段"
|
|
except Exception as e:
|
|
return 0.0, str(e)
|
|
|
|
|
|
# ─────────────────────────────────────────────
|
|
# Upstream cost — New-API / Nox-API
|
|
# ─────────────────────────────────────────────
|
|
|
|
def _new_api_failure_message(data: Any) -> str | None:
|
|
if not isinstance(data, dict):
|
|
return None
|
|
message = data.get("message") or data.get("detail") or data.get("error")
|
|
if data.get("success") is False:
|
|
return str(message or "上游返回 success=false")
|
|
if message and data.get("error"):
|
|
return str(message)
|
|
return None
|
|
|
|
|
|
def fetch_upstream_cost_new_api(upstream: Upstream, target_date: date) -> tuple[float, str | None]:
|
|
"""Fetch cost for New-API/Nox-API upstream via /api/log/self/stat.
|
|
|
|
Keeps UpstreamClient open for the full request so that:
|
|
- login_password token refresh is available if the stat call gets 401
|
|
- cookies are maintained throughout
|
|
- external API call is logged via _send_request → _do_request
|
|
|
|
Timestamp range: 00:00:00 to 23:59:59 Asia/Shanghai (closed interval per
|
|
New-API source: `created_at <= endTimestamp`).
|
|
"""
|
|
start_ts, end_ts = date_to_shanghai_timestamps(target_date)
|
|
auth_config = json.loads(upstream.auth_config_json or "{}")
|
|
try:
|
|
with UpstreamClient(
|
|
base_url=upstream.base_url,
|
|
api_prefix=upstream.api_prefix,
|
|
auth_type=upstream.auth_type,
|
|
auth_config=auth_config,
|
|
timeout=float(upstream.timeout_seconds),
|
|
on_auth_config_update=lambda _: None, # read-only, no DB write
|
|
target_id=upstream.id,
|
|
target_name=upstream.name,
|
|
) as client:
|
|
client.ensure_authenticated()
|
|
quota_per_unit = client._new_api_quota_per_unit()
|
|
params = {"type": 2, "start_timestamp": start_ts, "end_timestamp": end_ts}
|
|
resp = client._send_request("GET", client._url("/api/log/self/stat"), params=params)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
failure_message = _new_api_failure_message(data)
|
|
if failure_message:
|
|
return 0.0, failure_message
|
|
payload = data.get("data", data) if isinstance(data, dict) else {}
|
|
if isinstance(payload, dict):
|
|
quota = payload.get("quota")
|
|
if quota is not None:
|
|
cost = float(quota) / max(quota_per_unit, 1)
|
|
return round(cost, 6), None
|
|
return 0.0, "响应中找不到 quota 字段"
|
|
except Exception as e:
|
|
return 0.0, str(e)
|
|
|
|
|
|
# ─────────────────────────────────────────────
|
|
# Orchestration
|
|
# ─────────────────────────────────────────────
|
|
|
|
def get_daily_summary(
|
|
websites: list[Website],
|
|
upstreams: list[Upstream],
|
|
target_date: date,
|
|
) -> dict[str, Any]:
|
|
"""Compute daily revenue vs cost summary.
|
|
|
|
Never raises — each website/upstream failure is recorded in the item's
|
|
status/error fields. Failures do NOT contribute to totals (safe default:
|
|
under-count rather than over-count profit).
|
|
"""
|
|
website_items: list[dict[str, Any]] = []
|
|
upstream_items: list[dict[str, Any]] = []
|
|
total_revenue = 0.0
|
|
total_cost = 0.0
|
|
|
|
for w in websites:
|
|
amount, err = fetch_website_revenue(w, target_date)
|
|
item: dict[str, Any] = {
|
|
"id": w.id,
|
|
"name": w.name,
|
|
"upstream_type": "sub2api",
|
|
"amount": round(amount, 6),
|
|
"status": "failed" if err else "success",
|
|
"error": err,
|
|
}
|
|
website_items.append(item)
|
|
if not err:
|
|
total_revenue += amount
|
|
|
|
for u in upstreams:
|
|
utype = classify_upstream(u)
|
|
if utype == "sub2api":
|
|
amount, err = fetch_upstream_cost_sub2api(u, target_date)
|
|
elif utype == "new_api":
|
|
amount, err = fetch_upstream_cost_new_api(u, target_date)
|
|
else:
|
|
amount, err = 0.0, (
|
|
f"未知上游类型（auth_type={u.auth_type}, api_prefix={u.api_prefix}），"
|
|
"无法统计消费。请检查上游配置。"
|
|
)
|
|
|
|
item = {
|
|
"id": u.id,
|
|
"name": u.name,
|
|
"upstream_type": utype,
|
|
"amount": round(amount, 6),
|
|
"status": "failed" if err else "success",
|
|
"error": err,
|
|
}
|
|
upstream_items.append(item)
|
|
if not err:
|
|
total_cost += amount
|
|
|
|
net = total_revenue - total_cost
|
|
margin = (net / total_revenue * 100) if total_revenue > 0 else 0.0
|
|
failed_count = sum(1 for i in website_items + upstream_items if i["status"] == "failed")
|
|
|
|
return {
|
|
"date": target_date.isoformat(),
|
|
"total_revenue": round(total_revenue, 6),
|
|
"total_cost": round(total_cost, 6),
|
|
"net_income": round(net, 6),
|
|
"margin_percent": round(margin, 2),
|
|
"website_items": website_items,
|
|
"upstream_items": upstream_items,
|
|
"failed_count": failed_count,
|
|
"success": failed_count == 0,
|
|
}
|
|
|
|
|
|
# ─────────────────────────────────────────────
|
|
# DB-backed snapshot storage
|
|
# ─────────────────────────────────────────────
|
|
|
|
def _truncate_errors(summary: dict[str, Any], max_len: int = 500) -> None:
|
|
"""Truncate error messages in place to keep summary_json from growing unbounded."""
|
|
for item in summary.get("website_items", []) + summary.get("upstream_items", []):
|
|
err = item.get("error")
|
|
if err and len(err) > max_len:
|
|
item["error"] = err[:max_len] + "..."
|
|
|
|
|
|
def _save_summary(db: Session, date_key: date, summary: dict[str, Any]) -> datetime:
|
|
"""Save a computed summary to the database. Returns computed_at."""
|
|
_truncate_errors(summary)
|
|
from app.models.finance_daily_summary import FinanceDailySummary
|
|
now = datetime.now(timezone.utc)
|
|
row = FinanceDailySummary(
|
|
stat_date=date_key,
|
|
summary_json=json.dumps(summary, ensure_ascii=False, default=str),
|
|
success=summary.get("success", False),
|
|
computed_at=now,
|
|
)
|
|
db.add(row)
|
|
db.commit()
|
|
return now
|
|
|
|
|
|
def compute_daily_summary(
|
|
db: Session,
|
|
target_date: date,
|
|
) -> dict[str, Any]:
|
|
"""Compute a fresh daily summary (no DB write). Used for compare."""
|
|
websites = db.query(Website).filter(Website.enabled == True).all()
|
|
upstreams = db.query(Upstream).filter(Upstream.enabled == True).all()
|
|
return get_daily_summary(websites, upstreams, target_date)
|
|
|
|
|
|
def _load_summary(row: Any) -> dict[str, Any]:
|
|
"""Load summary dict from a FinanceDailySummary row, adding metadata."""
|
|
data = json.loads(row.summary_json)
|
|
data["computed_at"] = row.computed_at.isoformat()
|
|
data["from_snapshot"] = True
|
|
return data
|
|
|
|
|
|
def get_or_create_daily_summary(
|
|
db: Session,
|
|
target_date: date,
|
|
) -> dict[str, Any]:
|
|
"""Return stored summary for target_date, or compute + save if missing.
|
|
|
|
If a concurrent request already saved a row between our query and commit,
|
|
we rollback and return the existing row. This prevents duplicate-key errors.
|
|
"""
|
|
from app.models.finance_daily_summary import FinanceDailySummary
|
|
|
|
existing = db.query(FinanceDailySummary).filter(
|
|
FinanceDailySummary.stat_date == target_date
|
|
).first()
|
|
if existing:
|
|
return _load_summary(existing)
|
|
|
|
# Compute and save
|
|
summary = compute_daily_summary(db, target_date)
|
|
try:
|
|
now = _save_summary(db, target_date, summary)
|
|
except Exception:
|
|
db.rollback()
|
|
# Race: another request may have inserted this date. Read again.
|
|
existing = db.query(FinanceDailySummary).filter(
|
|
FinanceDailySummary.stat_date == target_date
|
|
).first()
|
|
if existing:
|
|
return _load_summary(existing)
|
|
# Not a race — real error. Re-raise.
|
|
raise
|
|
|
|
summary["computed_at"] = now.isoformat()
|
|
summary["from_snapshot"] = False
|
|
return summary
|
|
|
|
|
|
def save_summary_if_absent(
|
|
db: Session,
|
|
target_date: date,
|
|
) -> bool:
|
|
"""Compute and save summary for target_date if no snapshot exists yet.
|
|
|
|
Returns True if a new snapshot was saved, False if one already existed.
|
|
Safe against concurrent callers: on IntegrityError rolls back and
|
|
re-checks. Used by the scheduler cron job.
|
|
"""
|
|
from app.models.finance_daily_summary import FinanceDailySummary
|
|
|
|
existing = db.query(FinanceDailySummary).filter(
|
|
FinanceDailySummary.stat_date == target_date
|
|
).first()
|
|
if existing:
|
|
return False
|
|
|
|
summary = compute_daily_summary(db, target_date)
|
|
try:
|
|
_save_summary(db, target_date, summary)
|
|
return True
|
|
except Exception:
|
|
db.rollback()
|
|
# Race: another caller may have inserted this date.
|
|
existing = db.query(FinanceDailySummary).filter(
|
|
FinanceDailySummary.stat_date == target_date
|
|
).first()
|
|
if existing:
|
|
return False
|
|
raise
|
|
|
|
|
|
def overwrite_daily_summary(
|
|
db: Session,
|
|
target_date: date,
|
|
) -> dict[str, Any]:
|
|
"""Recompute and overwrite the stored snapshot for target_date.
|
|
|
|
Used when the user explicitly requests a refresh.
|
|
Deletes any existing row for this date first, then inserts the new one.
|
|
"""
|
|
from app.models.finance_daily_summary import FinanceDailySummary
|
|
|
|
db.query(FinanceDailySummary).filter(
|
|
FinanceDailySummary.stat_date == target_date
|
|
).delete()
|
|
db.flush()
|
|
|
|
summary = compute_daily_summary(db, target_date)
|
|
now = _save_summary(db, target_date, summary)
|
|
summary["computed_at"] = now.isoformat()
|
|
summary["from_snapshot"] = False
|
|
return summary
|