root
138 lines
4.5 KiB
Python
138 lines
4.5 KiB
Python
|
|
from io import BytesIO
|
|
import re
|
|
import xml.etree.ElementTree as ET
|
|
import zipfile
|
|
|
|
from fastapi import APIRouter, File, HTTPException, Query, UploadFile
|
|
|
|
from backend.database import db
|
|
from backend.schemas import CaseListResponse, CaseResponse, CaseUpdate, ParseDocResponse, DashboardResponse
|
|
|
|
router = APIRouter(prefix='/api/v1/admin', tags=['admin'])
|
|
|
|
|
|
def _parse_bool(value: str | None) -> bool | None:
|
|
if value is None:
|
|
return None
|
|
normalized = value.strip().lower()
|
|
if normalized in {'1', 'true', 'yes', 'y', 'да'}:
|
|
return True
|
|
if normalized in {'0', 'false', 'no', 'n', 'нет'}:
|
|
return False
|
|
return None
|
|
|
|
|
|
def _extract_docx_text(content: bytes) -> str:
|
|
with zipfile.ZipFile(BytesIO(content)) as archive:
|
|
xml = archive.read('word/document.xml')
|
|
root = ET.fromstring(xml)
|
|
ns = {'w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'}
|
|
paragraphs: list[str] = []
|
|
for paragraph in root.findall('.//w:body/w:p', ns):
|
|
texts = [node.text for node in paragraph.findall('.//w:t', ns) if node.text]
|
|
if texts:
|
|
paragraphs.append(''.join(texts).strip())
|
|
return '\n'.join(paragraphs).strip()
|
|
|
|
|
|
def _extract_kv_pairs(raw_text: str) -> dict[str, str]:
|
|
parsed: dict[str, str] = {}
|
|
for line in raw_text.splitlines():
|
|
if ':' not in line:
|
|
continue
|
|
key, value = line.split(':', 1)
|
|
parsed[key.strip().lower()] = value.strip()
|
|
return parsed
|
|
|
|
|
|
def _coerce_preview(raw_text: str) -> dict:
|
|
pairs = _extract_kv_pairs(raw_text)
|
|
case: dict[str, object] = {}
|
|
|
|
if 'age' in pairs:
|
|
try:
|
|
case['age'] = int(pairs['age'])
|
|
except ValueError:
|
|
pass
|
|
if 'gender' in pairs:
|
|
case['gender'] = pairs['gender']
|
|
if 'status' in pairs:
|
|
case['status'] = pairs['status']
|
|
if 'found alive' in pairs:
|
|
case['found_alive'] = _parse_bool(pairs['found alive'])
|
|
if 'found distance km' in pairs:
|
|
try:
|
|
case['found_distance_km'] = float(pairs['found distance km'])
|
|
except ValueError:
|
|
pass
|
|
if 'found lat' in pairs:
|
|
try:
|
|
case['found_lat'] = float(pairs['found lat'])
|
|
except ValueError:
|
|
pass
|
|
if 'found lon' in pairs:
|
|
try:
|
|
case['found_lon'] = float(pairs['found lon'])
|
|
except ValueError:
|
|
pass
|
|
if 'who found' in pairs:
|
|
case['who_found'] = pairs['who found']
|
|
if 'notes' in pairs:
|
|
case['notes'] = pairs['notes']
|
|
elif 'note' in pairs:
|
|
case['notes'] = pairs['note']
|
|
|
|
case_id = None
|
|
if 'case id' in pairs:
|
|
match = re.search(r'\d+', pairs['case id'])
|
|
if match:
|
|
case_id = match.group(0)
|
|
|
|
return {'raw_text': raw_text, 'case_id': case_id, 'case': case}
|
|
|
|
|
|
@router.get('/cases', response_model=CaseListResponse)
|
|
def admin_cases(
|
|
page: int = Query(default=1, ge=1),
|
|
page_size: int = Query(default=20, ge=1, le=100),
|
|
status: str | None = None,
|
|
age_min: int | None = Query(default=None, ge=0),
|
|
age_max: int | None = Query(default=None, ge=0),
|
|
) -> dict:
|
|
cases = db.list_cases()
|
|
if status:
|
|
cases = [c for c in cases if c.status == status]
|
|
if age_min is not None:
|
|
cases = [c for c in cases if c.age is not None and c.age >= age_min]
|
|
if age_max is not None:
|
|
cases = [c for c in cases if c.age is not None and c.age <= age_max]
|
|
start = (page - 1) * page_size
|
|
end = start + page_size
|
|
return {'items': [c.to_detail() for c in cases[start:end]], 'total': len(cases), 'page': page, 'page_size': page_size}
|
|
|
|
|
|
@router.patch('/cases/{case_id}', response_model=CaseResponse)
|
|
def admin_update_case(case_id: str, payload: CaseUpdate) -> dict:
|
|
data = payload.model_dump(exclude_none=True)
|
|
note = data.pop('note', None)
|
|
if note is not None and 'notes' not in data:
|
|
data['notes'] = note
|
|
case = db.update_case(case_id, **data)
|
|
if not case:
|
|
raise HTTPException(status_code=404, detail='Case not found')
|
|
return case.to_detail()
|
|
|
|
|
|
@router.get('/dashboard', response_model=DashboardResponse)
|
|
def admin_dashboard() -> dict:
|
|
return db.stats()
|
|
|
|
|
|
@router.post('/parse-doc', response_model=ParseDocResponse)
|
|
async def admin_parse_doc(file: UploadFile = File(...)) -> dict:
|
|
content = await file.read()
|
|
raw_text = _extract_docx_text(content)
|
|
preview = _coerce_preview(raw_text)
|
|
return {'filename': file.filename, 'parsed': True, 'preview': preview, 'raw_text': raw_text}
|