320 lines
12 KiB
Python
320 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
from datetime import date, datetime, time
|
|
from math import ceil
|
|
from typing import Any
|
|
|
|
from sqlalchemy import Select, Text, and_, desc, func, or_, select
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.models import CrawlRun, Employee
|
|
|
|
EMPLOYEE_SORTS = {
|
|
"full_name": Employee.full_name,
|
|
"status": Employee.status,
|
|
"first_seen_at": Employee.first_seen_at,
|
|
"last_seen_at": Employee.last_seen_at,
|
|
"dismissed_at": Employee.dismissed_at,
|
|
"hse_start_year": Employee.current_data["hse_start_year"].as_integer(),
|
|
}
|
|
|
|
|
|
def employee_display_payload(employee: Employee) -> dict[str, Any]:
|
|
data = employee.current_data or {}
|
|
contacts = data.get("contacts") or {}
|
|
sections = data.get("sections") or []
|
|
emails = contacts.get("emails") or []
|
|
phones = contacts.get("phones") or []
|
|
return {
|
|
"id": employee.id,
|
|
"full_name": employee.full_name,
|
|
"status": employee.status,
|
|
"canonical_url": employee.canonical_url,
|
|
"positions": data.get("positions") or [],
|
|
"positions_text": "; ".join(data.get("positions") or []),
|
|
"hse_start_year": data.get("hse_start_year"),
|
|
"emails": emails,
|
|
"email_text": ", ".join(emails),
|
|
"phones": phones,
|
|
"phone_text": ", ".join(phones),
|
|
"address": contacts.get("address"),
|
|
"publications_count": _count_section_items(sections, "publications"),
|
|
"courses_count": _count_section_items(sections, "courses_by_year"),
|
|
"first_seen_at": employee.first_seen_at.isoformat() if employee.first_seen_at else None,
|
|
"last_seen_at": employee.last_seen_at.isoformat() if employee.last_seen_at else None,
|
|
"dismissed_at": employee.dismissed_at.isoformat() if employee.dismissed_at else None,
|
|
}
|
|
|
|
|
|
def employee_detail_payload(employee: Employee) -> dict[str, Any]:
|
|
data = employee.current_data or {}
|
|
contacts = data.get("contacts") or {}
|
|
return {
|
|
**employee_display_payload(employee),
|
|
"profile_type": employee.profile_type or data.get("profile_type"),
|
|
"profile_id": employee.profile_id or data.get("profile_id"),
|
|
"parser_version": employee.parser_version or data.get("parser_version"),
|
|
"contacts": {
|
|
"emails": _clean_list(contacts.get("emails")),
|
|
"phones": _clean_list(contacts.get("phones")),
|
|
"address": contacts.get("address"),
|
|
"items": _normalize_contact_items(contacts.get("items")),
|
|
},
|
|
"external_ids": _normalize_external_ids(data.get("external_ids")),
|
|
"sections": [_normalize_section(section) for section in data.get("sections") or []],
|
|
}
|
|
|
|
|
|
def build_employee_query(
|
|
*,
|
|
status: str | None = None,
|
|
q: str | None = None,
|
|
started_from: date | None = None,
|
|
started_to: date | None = None,
|
|
has_email: bool | None = None,
|
|
) -> Select[tuple[Employee]]:
|
|
stmt = select(Employee)
|
|
filters = []
|
|
if status:
|
|
filters.append(Employee.status == status)
|
|
if q:
|
|
pattern = f"%{q}%"
|
|
filters.append(or_(Employee.full_name.ilike(pattern), Employee.canonical_url.ilike(pattern)))
|
|
if started_from:
|
|
filters.append(Employee.first_seen_at >= datetime.combine(started_from, time.min))
|
|
if started_to:
|
|
filters.append(Employee.first_seen_at <= datetime.combine(started_to, time.max))
|
|
if has_email is True:
|
|
filters.append(Employee.current_data.cast(Text).ilike("%@%"))
|
|
elif has_email is False:
|
|
filters.append(or_(Employee.current_data.is_(None), ~Employee.current_data.cast(Text).ilike("%@%")))
|
|
if filters:
|
|
stmt = stmt.where(and_(*filters))
|
|
return stmt
|
|
|
|
|
|
def list_employees_page(
|
|
db: Session,
|
|
*,
|
|
status: str | None = None,
|
|
q: str | None = None,
|
|
started_from: date | None = None,
|
|
started_to: date | None = None,
|
|
has_email: bool | None = None,
|
|
sort: str = "full_name",
|
|
direction: str = "asc",
|
|
limit: int = 50,
|
|
offset: int = 0,
|
|
) -> dict[str, Any]:
|
|
limit = max(1, min(limit, 200))
|
|
offset = max(0, offset)
|
|
base_stmt = build_employee_query(
|
|
status=status,
|
|
q=q,
|
|
started_from=started_from,
|
|
started_to=started_to,
|
|
has_email=has_email,
|
|
)
|
|
total = db.scalar(select(func.count()).select_from(base_stmt.subquery())) or 0
|
|
sort_column = EMPLOYEE_SORTS.get(sort, Employee.full_name)
|
|
order = desc(sort_column) if direction == "desc" else sort_column
|
|
employees = db.scalars(base_stmt.order_by(order).limit(limit).offset(offset)).all()
|
|
return {
|
|
"items": [employee_display_payload(employee) for employee in employees],
|
|
"total": total,
|
|
"limit": limit,
|
|
"offset": offset,
|
|
"pages": ceil(total / limit) if total else 0,
|
|
"page": (offset // limit) + 1,
|
|
}
|
|
|
|
|
|
def stats_payload(db: Session) -> dict[str, Any]:
|
|
latest_run = db.scalar(select(CrawlRun).order_by(desc(CrawlRun.started_at)).limit(1))
|
|
running_run = db.scalar(select(CrawlRun).where(CrawlRun.status == "running").order_by(desc(CrawlRun.started_at)).limit(1))
|
|
latest_added = db.scalar(select(Employee).order_by(desc(Employee.first_seen_at)).limit(1))
|
|
return {
|
|
"total": db.scalar(select(func.count()).select_from(Employee)) or 0,
|
|
"active": db.scalar(select(func.count()).select_from(Employee).where(Employee.status == "active")) or 0,
|
|
"dismissed": db.scalar(select(func.count()).select_from(Employee).where(Employee.status == "dismissed")) or 0,
|
|
"new_in_last_run": latest_run.new_count if latest_run else 0,
|
|
"latest_added": employee_display_payload(latest_added) if latest_added else None,
|
|
"latest_run": run_payload(latest_run) if latest_run else None,
|
|
"current_running_run": run_payload(running_run) if running_run else None,
|
|
}
|
|
|
|
|
|
def run_payload(run: CrawlRun | None) -> dict[str, Any] | None:
|
|
if not run:
|
|
return None
|
|
processed = run.parsed_count + run.error_count
|
|
percent = round((processed / run.found_count) * 100, 1) if run.found_count else 0
|
|
return {
|
|
"id": run.id,
|
|
"source_url": run.source_url,
|
|
"status": run.status,
|
|
"started_at": run.started_at.isoformat() if run.started_at else None,
|
|
"finished_at": run.finished_at.isoformat() if run.finished_at else None,
|
|
"found_count": run.found_count,
|
|
"parsed_count": run.parsed_count,
|
|
"new_count": run.new_count,
|
|
"error_count": run.error_count,
|
|
"dismissed_count": run.dismissed_count,
|
|
"processed_count": processed,
|
|
"progress_percent": percent,
|
|
"message": run.message,
|
|
}
|
|
|
|
|
|
def _count_section_items(sections: list[dict[str, Any]], section_type: str) -> int:
|
|
total = 0
|
|
for section in sections:
|
|
if section.get("type") != section_type:
|
|
continue
|
|
if section_type == "publications":
|
|
total += len(section.get("publications") or section.get("items") or [])
|
|
elif section_type == "courses_by_year":
|
|
total += len(section.get("courses") or [])
|
|
return total
|
|
|
|
|
|
def _clean_list(values: Any) -> list[str]:
|
|
if not isinstance(values, list):
|
|
return []
|
|
return [str(value).strip() for value in values if str(value or "").strip()]
|
|
|
|
|
|
def _normalize_contact_items(items: Any) -> list[str]:
|
|
normalized = []
|
|
if not isinstance(items, list):
|
|
return normalized
|
|
for item in items:
|
|
if isinstance(item, dict):
|
|
value = item.get("raw") or item.get("value") or item.get("text")
|
|
else:
|
|
value = item
|
|
value = str(value or "").strip()
|
|
if value:
|
|
normalized.append(value)
|
|
return normalized
|
|
|
|
|
|
def _normalize_external_ids(items: Any) -> list[dict[str, str | None]]:
|
|
normalized = []
|
|
if not isinstance(items, list):
|
|
return normalized
|
|
for item in items:
|
|
if not isinstance(item, dict):
|
|
continue
|
|
system = str(item.get("system") or "").strip()
|
|
value = str(item.get("value") or "").strip()
|
|
url = str(item.get("url") or "").strip()
|
|
if system or value or url:
|
|
normalized.append({"system": system or "ID", "value": value or url, "url": url or None})
|
|
return normalized
|
|
|
|
|
|
def _normalize_section(section: Any) -> dict[str, Any]:
|
|
if not isinstance(section, dict):
|
|
return {"title": "Раздел", "type": "generic", "paragraphs": [str(section)], "items": [], "links": []}
|
|
|
|
section_type = section.get("type") or "generic"
|
|
paragraphs = _clean_list(section.get("paragraphs"))
|
|
items = _clean_list(section.get("items"))
|
|
raw_text = str(section.get("raw_text") or "").strip()
|
|
if not paragraphs and not items and raw_text:
|
|
paragraphs = [raw_text]
|
|
|
|
return {
|
|
"title": section.get("title") or "Раздел",
|
|
"type": section_type,
|
|
"raw_text": raw_text,
|
|
"paragraphs": paragraphs,
|
|
"items": items,
|
|
"links": _normalize_links(section.get("links")),
|
|
"year_entries": _normalize_year_entries(section.get("year_entries")),
|
|
"publications": _normalize_publications(section.get("publications")),
|
|
"publications_count": section.get("publications_count"),
|
|
"academic_year": section.get("academic_year"),
|
|
"courses": _normalize_courses(section.get("courses")),
|
|
"table": _normalize_table(section.get("table")),
|
|
}
|
|
|
|
|
|
def _normalize_links(items: Any) -> list[dict[str, str | None]]:
|
|
normalized = []
|
|
if not isinstance(items, list):
|
|
return normalized
|
|
for item in items:
|
|
if not isinstance(item, dict):
|
|
continue
|
|
text = str(item.get("text") or item.get("url") or "").strip()
|
|
url = str(item.get("url") or "").strip()
|
|
if text and url:
|
|
normalized.append({"text": text, "url": url})
|
|
return normalized
|
|
|
|
|
|
def _normalize_year_entries(items: Any) -> list[dict[str, Any]]:
|
|
normalized = []
|
|
if not isinstance(items, list):
|
|
return normalized
|
|
for item in items:
|
|
if not isinstance(item, dict):
|
|
continue
|
|
text = str(item.get("text") or "").strip()
|
|
if text:
|
|
normalized.append({"year": item.get("year"), "text": text, "links": _normalize_links(item.get("links"))})
|
|
return normalized
|
|
|
|
|
|
def _normalize_publications(items: Any) -> list[dict[str, str | None]]:
|
|
normalized = []
|
|
if not isinstance(items, list):
|
|
return normalized
|
|
for item in items:
|
|
if not isinstance(item, dict):
|
|
text = str(item or "").strip()
|
|
if text:
|
|
normalized.append({"title": text, "text": text, "url": None})
|
|
continue
|
|
title = str(item.get("title") or "").strip()
|
|
text = str(item.get("text") or title).strip()
|
|
url = str(item.get("url") or "").strip()
|
|
if title or text:
|
|
normalized.append({"title": title or text, "text": text or title, "url": url or None})
|
|
return normalized
|
|
|
|
|
|
def _normalize_courses(items: Any) -> list[dict[str, str | None]]:
|
|
normalized = []
|
|
if not isinstance(items, list):
|
|
return normalized
|
|
for item in items:
|
|
if not isinstance(item, dict):
|
|
title = str(item or "").strip()
|
|
if title:
|
|
normalized.append({"title": title, "url": None})
|
|
continue
|
|
title = str(item.get("title") or "").strip()
|
|
url = str(item.get("url") or "").strip()
|
|
if title or url:
|
|
normalized.append({"title": title or url, "url": url or None})
|
|
return normalized
|
|
|
|
|
|
def _normalize_table(table: Any) -> dict[str, Any] | None:
|
|
if not isinstance(table, dict):
|
|
return None
|
|
headers = _clean_list(table.get("headers"))
|
|
rows = []
|
|
for row in table.get("rows") or []:
|
|
if not isinstance(row, dict):
|
|
continue
|
|
cells = _clean_list(row.get("cells"))
|
|
if cells:
|
|
rows.append({"cells": cells, "link_url": row.get("link_url")})
|
|
if not headers and not rows:
|
|
return None
|
|
return {"headers": headers, "rows": rows}
|