360 lines
15 KiB
Python
360 lines
15 KiB
Python
"""API blueprint — groups, documents, supplements, sync, cleanup, spec-current, chat."""
|
||
import csv
|
||
import io
|
||
import json
|
||
from datetime import date
|
||
from flask import Blueprint, request, jsonify
|
||
from db import documents, supplements, spec_current
|
||
from db import dossiers as db_dossiers
|
||
from db import exceptions as db_exceptions
|
||
from db import timeline as db_timeline
|
||
from db import extractions as db_extractions
|
||
from db.connection import execute, query, transaction
|
||
from services.grouping import group_documents, apply_groups
|
||
from services.reconciliation import reconcile_dossier
|
||
from services.timeline_builder import build_dossier_timeline
|
||
from config import LLM_URL, LLM_KEY, LLM_MODEL
|
||
import httpx
|
||
|
||
api_bp = Blueprint("api", __name__)
|
||
|
||
|
||
# ── Contract timeline and exceptions ────────────────────────────
|
||
|
||
@api_bp.route("/api/dossiers/<dossier_id>/timeline")
|
||
def api_dossier_timeline(dossier_id):
|
||
"""Вернуть полную историю и активный срез обязательств dossier."""
|
||
dossier = db_dossiers.get_dossier(dossier_id)
|
||
if not dossier:
|
||
return jsonify(ok=False, error="dossier not found"), 404
|
||
|
||
as_of = request.args.get("as_of") or date.today().isoformat()
|
||
try:
|
||
as_of = date.fromisoformat(as_of).isoformat()
|
||
except ValueError:
|
||
return jsonify(ok=False, error="as_of must be YYYY-MM-DD"), 400
|
||
|
||
history = db_timeline.list_timeline(dossier_id)
|
||
active = db_timeline.list_timeline(dossier_id, as_of)
|
||
for interval in history + active:
|
||
try:
|
||
interval["config_params"] = json.loads(interval.get("config_params_json") or "{}")
|
||
except (TypeError, json.JSONDecodeError):
|
||
interval["config_params"] = {}
|
||
return jsonify(
|
||
ok=True,
|
||
dossier=dossier,
|
||
as_of=as_of,
|
||
timeline=history,
|
||
active=active,
|
||
exceptions=db_exceptions.list_exceptions(dossier_id=dossier_id, status="OPEN"),
|
||
)
|
||
|
||
|
||
@api_bp.route("/api/dossiers")
|
||
def api_dossiers():
|
||
"""Вернуть dossier cards batch вместе с alias и связанными документами."""
|
||
batch_id = request.args.get("batch_id")
|
||
if not batch_id:
|
||
return jsonify(ok=False, error="batch_id required"), 400
|
||
dossiers = db_dossiers.list_dossiers_by_batch(batch_id)
|
||
extractions_by_document = {
|
||
extraction["document_id"]: extraction
|
||
for extraction in db_extractions.list_by_batch(batch_id)
|
||
}
|
||
for dossier in dossiers:
|
||
for document in dossier.get("documents", []):
|
||
extraction = extractions_by_document.get(document.get("document_id"))
|
||
validation = (extraction or {}).get("math_validation") or {}
|
||
document["math_status"] = validation.get("status", "UNKNOWN")
|
||
return jsonify(
|
||
ok=True,
|
||
dossiers=dossiers,
|
||
)
|
||
|
||
|
||
@api_bp.route("/api/exceptions")
|
||
def api_exceptions():
|
||
"""Вернуть исключения только по явно заданной области batch или dossier."""
|
||
batch_id = request.args.get("batch_id")
|
||
dossier_id = request.args.get("dossier_id")
|
||
status = request.args.get("status")
|
||
if not batch_id and not dossier_id:
|
||
return jsonify(ok=False, error="batch_id or dossier_id required"), 400
|
||
if status and status not in {"OPEN", "RESOLVED"}:
|
||
return jsonify(ok=False, error="status must be OPEN or RESOLVED"), 400
|
||
return jsonify(
|
||
ok=True,
|
||
exceptions=db_exceptions.list_exceptions(
|
||
batch_id=batch_id, dossier_id=dossier_id, status=status,
|
||
),
|
||
)
|
||
|
||
|
||
@api_bp.route("/api/reconcile", methods=["POST"])
|
||
def api_reconcile():
|
||
"""Сверить JSON или CSV строки внешнего биллинга с эталоном dossier."""
|
||
content_type = request.mimetype or ""
|
||
if content_type == "application/json":
|
||
body = request.get_json(silent=True) or {}
|
||
dossier_id = body.get("dossier_id")
|
||
rows = body.get("external_rows")
|
||
target = body.get("target_date_or_period")
|
||
catalog_entries = body.get("catalog_entries", [])
|
||
elif content_type == "multipart/form-data":
|
||
dossier_id = request.form.get("dossier_id")
|
||
upload = request.files.get("file")
|
||
if upload is None:
|
||
return jsonify(ok=False, error="CSV file required"), 400
|
||
try:
|
||
rows = list(csv.DictReader(io.StringIO(upload.stream.read().decode("utf-8-sig"))))
|
||
except (UnicodeDecodeError, csv.Error):
|
||
return jsonify(ok=False, error="CSV must be UTF-8 with a header row"), 400
|
||
target = request.form.get("target_date_or_period")
|
||
if target:
|
||
try:
|
||
target = json.loads(target)
|
||
except json.JSONDecodeError:
|
||
return jsonify(ok=False, error="target_date_or_period must be JSON"), 400
|
||
catalog_entries = request.form.get("catalog_entries", "[]")
|
||
try:
|
||
catalog_entries = json.loads(catalog_entries)
|
||
except json.JSONDecodeError:
|
||
return jsonify(ok=False, error="catalog_entries must be JSON"), 400
|
||
else:
|
||
return jsonify(ok=False, error="use application/json or multipart/form-data"), 415
|
||
|
||
if not isinstance(dossier_id, str) or not dossier_id.strip():
|
||
return jsonify(ok=False, error="dossier_id required"), 400
|
||
if not isinstance(rows, list) or any(not isinstance(row, dict) for row in rows):
|
||
return jsonify(ok=False, error="external_rows must be an array of objects"), 400
|
||
if not isinstance(catalog_entries, list) or any(not isinstance(row, dict) for row in catalog_entries):
|
||
return jsonify(ok=False, error="catalog_entries must be an array of objects"), 400
|
||
try:
|
||
result = reconcile_dossier(dossier_id, rows, target, catalog_entries)
|
||
except ValueError as error:
|
||
return jsonify(ok=False, error=str(error)), 400
|
||
if not result.get("ok"):
|
||
return jsonify(result), 404
|
||
return jsonify(result)
|
||
|
||
|
||
@api_bp.route("/api/exceptions/<exception_id>/resolve", methods=["POST"])
|
||
def api_resolve_exception(exception_id):
|
||
"""Сохранить выбор оператора и без LLM пересобрать dossier timeline."""
|
||
issue = db_exceptions.get_exception(exception_id)
|
||
if not issue:
|
||
return jsonify(ok=False, error="exception not found"), 404
|
||
if issue.get("status") != "OPEN":
|
||
return jsonify(ok=False, error="exception is not open"), 409
|
||
body = request.get_json(silent=True) or {}
|
||
resolution = body.get("resolution")
|
||
if not isinstance(resolution, dict) or not resolution:
|
||
return jsonify(ok=False, error="resolution object required"), 400
|
||
|
||
options = issue.get("options") or []
|
||
if "option_index" in resolution:
|
||
option_index = resolution["option_index"]
|
||
if type(option_index) is not int or not 0 <= option_index < len(options):
|
||
return jsonify(ok=False, error="option_index is invalid"), 400
|
||
resolution = {
|
||
"option_index": option_index,
|
||
"selected_option": options[option_index],
|
||
}
|
||
elif issue.get("stage") == "lineage_matching" and options:
|
||
return jsonify(ok=False, error="choose an option_index"), 400
|
||
|
||
if issue.get("dossier_id") and not db_dossiers.get_dossier(issue["dossier_id"]):
|
||
return jsonify(ok=False, error="dossier not found"), 404
|
||
resolved = db_exceptions.resolve_exception(exception_id, resolution)
|
||
if not resolved:
|
||
return jsonify(ok=False, error="exception is not open"), 409
|
||
|
||
rebuild = None
|
||
if issue.get("dossier_id"):
|
||
rebuild = build_dossier_timeline(issue["dossier_id"])
|
||
if not rebuild.get("ok"):
|
||
return jsonify(ok=False, error="timeline rebuild failed", rebuild=rebuild), 500
|
||
return jsonify(ok=True, exception=resolved, rebuild=rebuild)
|
||
|
||
|
||
# ── Supplements ──────────────────────────────────────────────────
|
||
|
||
@api_bp.route("/api/supplements")
|
||
def api_supplements():
|
||
cid = request.args.get("contract_id")
|
||
if not cid:
|
||
return jsonify(ok=False, error="contract_id required"), 400
|
||
rows = supplements.list_by_contract(cid)
|
||
return jsonify(ok=True, supplements=rows)
|
||
|
||
|
||
# ── Documents ────────────────────────────────────────────────────
|
||
|
||
@api_bp.route("/api/documents/<doc_id>")
|
||
def api_document(doc_id):
|
||
doc = documents.get(doc_id)
|
||
if not doc:
|
||
return jsonify(ok=False, error="not found"), 404
|
||
return jsonify(ok=True, **{
|
||
k: doc.get(k) for k in [
|
||
"id", "filename", "status", "elements_json", "doc_type",
|
||
"own_number", "parent_number", "doc_date", "counterparty",
|
||
"classify_status", "classify_raw", "classify_input",
|
||
]
|
||
})
|
||
|
||
|
||
@api_bp.route("/api/documents/<doc_id>", methods=["DELETE"])
|
||
def api_document_delete(doc_id):
|
||
if not documents.get(doc_id):
|
||
return jsonify(ok=False, error="not found"), 404
|
||
with transaction():
|
||
contract_ids = _delete_document(doc_id)
|
||
_delete_orphan_contracts(contract_ids)
|
||
return jsonify(ok=True)
|
||
|
||
|
||
def _delete_document(doc_id):
|
||
supps = query("SELECT id, contract_id FROM supplements WHERE document_id = %s", (doc_id,))
|
||
contract_ids = {row["contract_id"] for row in supps}
|
||
for supp in supps:
|
||
execute(
|
||
"""DELETE FROM spec_current WHERE contract_id = %s
|
||
AND last_event_id IN (SELECT id FROM spec_events WHERE supplement_id = %s)""",
|
||
(supp["contract_id"], supp["id"]),
|
||
)
|
||
execute("DELETE FROM spec_events WHERE supplement_id = %s", (supp["id"],))
|
||
execute("DELETE FROM supplements WHERE id = %s", (supp["id"],))
|
||
execute("DELETE FROM documents WHERE id = %s", (doc_id,))
|
||
return contract_ids
|
||
|
||
|
||
def _delete_orphan_contracts(contract_ids):
|
||
for contract_id in contract_ids:
|
||
remaining = query(
|
||
"SELECT id FROM supplements WHERE contract_id = %s LIMIT 1",
|
||
(contract_id,),
|
||
)
|
||
if not remaining:
|
||
execute("DELETE FROM contracts WHERE id = %s", (contract_id,))
|
||
|
||
|
||
# ── Sync ─────────────────────────────────────────────────────────
|
||
|
||
@api_bp.route("/api/sync", methods=["POST"])
|
||
def api_sync():
|
||
"""Remove documents absent from keep_ids in the specified batch only."""
|
||
body = request.get_json(silent=True) or {}
|
||
batch_id = body.get("batch_id")
|
||
keep_ids = body.get("keep_ids", [])
|
||
if not isinstance(batch_id, str) or not batch_id.strip():
|
||
return jsonify(ok=False, error="batch_id required"), 400
|
||
if not isinstance(keep_ids, list) or any(not isinstance(doc_id, str) for doc_id in keep_ids):
|
||
return jsonify(ok=False, error="keep_ids must be a list of document IDs"), 400
|
||
if len(keep_ids) > 1000:
|
||
return jsonify(ok=False, error="too many keep_ids (max 1000)"), 400
|
||
|
||
docs = query("SELECT id FROM documents WHERE batch_id = %s", (batch_id,))
|
||
deleted = 0
|
||
contract_ids = set()
|
||
keep_ids = set(keep_ids)
|
||
with transaction():
|
||
for doc in docs:
|
||
if doc["id"] in keep_ids:
|
||
continue
|
||
contract_ids.update(_delete_document(doc["id"]))
|
||
deleted += 1
|
||
_delete_orphan_contracts(contract_ids)
|
||
return jsonify(ok=True, deleted=deleted)
|
||
|
||
|
||
# ── Groups ───────────────────────────────────────────────────────
|
||
|
||
@api_bp.route("/api/groups")
|
||
def api_groups():
|
||
batch_id = request.args.get("batch")
|
||
if not batch_id:
|
||
return jsonify(ok=False, error="batch required"), 400
|
||
result = group_documents(batch_id)
|
||
return jsonify(result)
|
||
|
||
|
||
@api_bp.route("/api/batch-progress")
|
||
def api_batch_progress():
|
||
batch_id = request.args.get("batch")
|
||
if not batch_id:
|
||
return jsonify(ok=False, error="batch required"), 400
|
||
counts = documents.count_by_status(batch_id)
|
||
docs = documents.list_by_batch(batch_id)
|
||
return jsonify(ok=True, counts=counts, total=len(docs))
|
||
|
||
|
||
@api_bp.route("/api/apply-groups", methods=["POST"])
|
||
def api_apply_groups():
|
||
body = request.get_json()
|
||
batch_id = body.get("batch_id")
|
||
groups = body.get("groups", [])
|
||
if not batch_id:
|
||
return jsonify(ok=False, error="batch_id required"), 400
|
||
result = apply_groups(batch_id, groups)
|
||
return jsonify(result)
|
||
|
||
|
||
# ── Spec current ─────────────────────────────────────────────────
|
||
|
||
@api_bp.route("/api/spec-current")
|
||
def api_spec_current():
|
||
cid = request.args.get("contract_id")
|
||
if not cid:
|
||
return jsonify(ok=False, error="contract_id required"), 400
|
||
rows = spec_current.list_by_contract(cid)
|
||
return jsonify(ok=True, rows=rows)
|
||
|
||
|
||
# ── Chat (совместимость с Lucee /chat.cfm) ──────────────────────
|
||
|
||
@api_bp.route("/chat", methods=["POST"])
|
||
@api_bp.route("/chat.cfm", methods=["POST"])
|
||
def chat():
|
||
"""Чат с LLM по данным спецификации. Совместим с Lucee-форматом ответа."""
|
||
contract_id = request.args.get("contract_id", "")
|
||
question = request.form.get("question", "")
|
||
if not contract_id or not question:
|
||
return jsonify(OK=False, ERROR="contract_id and question required")
|
||
|
||
rows = spec_current.list_by_contract(contract_id)
|
||
if not rows:
|
||
return jsonify(OK=True, ANSWER="Нет данных. Сначала запустите сравнение.")
|
||
|
||
ctx = "\n".join(
|
||
f"{r.get('name','')} | цена={r.get('price')} | объём={r.get('qty')} | "
|
||
f"сумма={r.get('sum')} | начало={r.get('date_start')}"
|
||
for r in rows
|
||
)
|
||
prompt = (
|
||
f"Ты — анализатор договоров. Данные:\n{ctx}\n\n"
|
||
f"Вопрос: {question}\nОтветь кратко, только по данным."
|
||
)
|
||
|
||
try:
|
||
with httpx.Client(timeout=120) as client:
|
||
resp = client.post(
|
||
LLM_URL,
|
||
json={
|
||
"model": LLM_MODEL,
|
||
"messages": [{"role": "user", "content": prompt}],
|
||
"max_tokens": 1000,
|
||
"temperature": 0.1,
|
||
},
|
||
headers={
|
||
"Authorization": f"Bearer {LLM_KEY}",
|
||
"Content-Type": "application/json",
|
||
},
|
||
)
|
||
resp.raise_for_status()
|
||
answer = resp.json()["choices"][0]["message"]["content"]
|
||
return jsonify(OK=True, ANSWER=answer)
|
||
except Exception as e:
|
||
return jsonify(OK=False, ERROR=f"LLM error: {e}")
|