recept/StahovánízVZPWithClaude/import_vzp_pracoviste.py

"""
Import VZP číselníku pracovišť (soubory *.Lh7) do MySQL tabulky vzp_pracoviste.
Před importem automaticky stáhne nejnovější soubor z VZP Point (vyžaduje certifikát).
Použití: python import_vzp_pracoviste.py [--no-download] [soubor.Lh7]
"""

import base64
import csv
import glob
import hashlib
import io
import os
import re
import secrets
import sys
import zipfile
from datetime import date, datetime
from html.parser import HTMLParser

# Windows konzole - povol UTF-8 výstup
if sys.stdout.encoding != "utf-8":
    import io
    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")

import mysql.connector

DB_CONFIG = {
    "host": "192.168.1.76",
    "user": "root",
    "password": "Vlado9674+",
    "database": "medicus",
    "charset": "utf8mb4",
}

IMPORT_DIR = os.path.join(os.path.dirname(__file__), "Import")

VZP_CERT_FILE     = os.path.join(os.path.dirname(__file__), "MichalkaPublicCertProPython.pfx")
VZP_CERT_PASSWORD = "Vlado7309208104++"
VZP_DOCUMENT_ID   = 5283   # "Soubor platných IČP" na point.vzp.cz/Cms/Document

CREATE_TABLE_SQL = """
CREATE TABLE IF NOT EXISTS vzp_pracoviste (
    id               INT           NOT NULL AUTO_INCREMENT,
    ico              CHAR(8)       NOT NULL,
    icz              CHAR(8)       NOT NULL,
    icp              CHAR(8)       NOT NULL,
    odbornost        VARCHAR(4)    NOT NULL,
    platnost_od      DATE          NOT NULL,
    platnost_do      DATE          NOT NULL,
    nazev_zarizeni   VARCHAR(200),
    nazev_pracoviste VARCHAR(200),
    ulice            VARCHAR(150),
    mesto            VARCHAR(100),
    psc              CHAR(5),
    PRIMARY KEY (id),
    INDEX idx_icp (icp),
    INDEX idx_icz (icz),
    INDEX idx_odbornost (odbornost),
    INDEX idx_platnost (platnost_od, platnost_do)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
"""

BATCH_SIZE = 1000


def parse_date(s: str) -> date | None:
    """Převede DDMMYYYY na date. Rok 3000 → 9999-12-31."""
    s = s.strip()
    if len(s) != 8:
        return None
    try:
        d, m, y = int(s[0:2]), int(s[2:4]), int(s[4:8])
        if y >= 3000:
            return date(9999, 12, 31)
        return date(y, m, d)
    except ValueError:
        return None


def _pkce_pair() -> tuple[str, str]:
    """Vrátí (code_verifier, code_challenge) pro PKCE S256."""
    verifier = secrets.token_urlsafe(64)
    digest = hashlib.sha256(verifier.encode()).digest()
    challenge = base64.urlsafe_b64encode(digest).rstrip(b"=").decode()
    return verifier, challenge


def _get_bearer_token() -> str | None:
    """
    Autentizuje pomocí PKCS12 certifikátu přes OIDC authorization_code + PKCE.
    Certifikát je předán při TLS handshake na auth.vzp.cz.
    Vrátí Bearer access_token nebo None při chybě.
    """
    try:
        import requests
        from requests_pkcs12 import Pkcs12Adapter
    except ImportError:
        print("[auth] pip install requests requests-pkcs12")
        return None

    password = VZP_CERT_PASSWORD.encode() if VZP_CERT_PASSWORD else None
    verifier, challenge = _pkce_pair()
    nonce = secrets.token_urlsafe(32)
    state = secrets.token_urlsafe(32)

    session = requests.Session()
    # Certifikát pro TLS client auth na auth.vzp.cz i pro redirect na point.vzp.cz
    for base in ("https://auth.vzp.cz", "https://point.vzp.cz"):
        session.mount(base, Pkcs12Adapter(pkcs12_filename=VZP_CERT_FILE, pkcs12_password=password))

    # Krok 1: Authorize — server ověří certifikát a vrátí form_post HTML s code
    try:
        resp = session.get(
            "https://auth.vzp.cz/connect/authorize",
            params={
                "client_id":             "bdesk",
                "redirect_uri":          "https://point.vzp.cz/home/signin",
                "response_type":         "code",
                "scope":                 "openid profile email phone offline_access",
                "response_mode":         "form_post",
                "nonce":                 nonce,
                "state":                 state,
                "code_challenge":        challenge,
                "code_challenge_method": "S256",
            },
            allow_redirects=True,
            timeout=30,
        )
    except Exception as e:
        print(f"[auth] Chyba při authorize: {e}")
        return None

    # Parsuj form_post HTML a vytáhni code
    class _FormParser(HTMLParser):
        def __init__(self):
            super().__init__()
            self.fields: dict[str, str] = {}
        def handle_starttag(self, tag, attrs):
            if tag == "input":
                d = dict(attrs)
                if d.get("name"):
                    self.fields[d["name"]] = d.get("value", "")

    fp = _FormParser()
    fp.feed(resp.text)
    code = fp.fields.get("code")

    if not code:
        print(f"[auth] Autorizační kód nenalezen (HTTP {resp.status_code}). "
              f"Zkontroluj certifikát a heslo PFX.")
        return None

    # Krok 2: Vyměň code za access_token
    try:
        token_resp = session.post(
            "https://auth.vzp.cz/connect/token",
            data={
                "grant_type":    "authorization_code",
                "code":          code,
                "redirect_uri":  "https://point.vzp.cz/home/signin",
                "client_id":     "bdesk",
                "code_verifier": verifier,
            },
            timeout=30,
        )
        token_data = token_resp.json()
    except Exception as e:
        print(f"[auth] Chyba při výměně tokenu: {e}")
        return None

    token = token_data.get("access_token")
    if not token:
        print(f"[auth] access_token chybí. Odpověď: {list(token_data.keys())}")
        return None

    return token


def _get_icp_filename(session, token: str) -> str | None:
    """
    Zjistí aktuální název ICP zip souboru z point.vzp.cz/Cms/Document
    (atribut download na odkazu 'Soubor platných IČP').
    """
    try:
        resp = session.get("https://point.vzp.cz/Cms/Document", timeout=30)
        resp.raise_for_status()
    except Exception as e:
        print(f"[stahování] Nelze načíst seznam dokumentů: {e}")
        return None

    class _DownloadParser(HTMLParser):
        def __init__(self):
            super().__init__()
            self.filename: str | None = None
        def handle_starttag(self, tag, attrs):
            if tag == "a" and not self.filename:
                d = dict(attrs)
                dl = d.get("download", "")
                if re.search(r"-icp\.zip$", dl, re.IGNORECASE):
                    self.filename = dl

    dp = _DownloadParser()
    dp.feed(resp.text)
    return dp.filename


def download_latest_file() -> str | None:
    """
    1. Autentizuje certifikátem přes OIDC → Bearer token
    2. Zjistí aktuální název ICP zip z point.vzp.cz
    3. Získá SAS URL z www.vzp.cz/api/documents/{id}/files/{filename}
    4. Stáhne ZIP, rozbalí PLP111*.Lh7 do Import/
    Vrátí cestu k Lh7 nebo None při chybě.
    """
    try:
        import requests
        from requests_pkcs12 import Pkcs12Adapter
    except ImportError:
        print("[stahování] pip install requests requests-pkcs12")
        return None

    password = VZP_CERT_PASSWORD.encode() if VZP_CERT_PASSWORD else None

    # Session s certifikátem (pro point.vzp.cz po autentizaci)
    session = requests.Session()
    for base in ("https://auth.vzp.cz", "https://point.vzp.cz"):
        session.mount(base, Pkcs12Adapter(pkcs12_filename=VZP_CERT_FILE, pkcs12_password=password))

    # Autentizace
    print("[stahování] Přihlašování certifikátem...")
    token = _get_bearer_token()
    if not token:
        return None
    print("[stahování] Přihlášení úspěšné.")

    # Zjisti název souboru
    zip_filename = _get_icp_filename(session, token)
    if not zip_filename:
        print("[stahování] Název ICP souboru nenalezen.")
        return None

    # Zkontroluj, jestli Lh7 pro tento rok už máme
    year_match = re.search(r"^(\d{2})", zip_filename)
    year = year_match.group(1) if year_match else ""
    existing = glob.glob(os.path.join(IMPORT_DIR, f"PLP111{year}.Lh7"))
    if existing:
        print(f"[stahování] {os.path.basename(existing[0])} již existuje — přeskočeno.")
        return existing[0]

    # Získej SAS URL pro stažení
    api_url = f"https://www.vzp.cz/api/documents/{VZP_DOCUMENT_ID}/files/{zip_filename}"
    print(f"[stahování] Získávám odkaz ke stažení...")
    try:
        api_resp = requests.get(
            api_url,
            headers={
                "Authorization": f"Bearer {token}",
                "Origin":        "https://point.vzp.cz",
                "Referer":       "https://point.vzp.cz/",
            },
            timeout=30,
        )
        api_resp.raise_for_status()
        # Odpověď je SAS URL jako JSON string nebo objekt
        try:
            data = api_resp.json()
            sas_url = data if isinstance(data, str) else (
                data.get("url") or data.get("sasUrl") or data.get("uri") or data.get("value")
            )
        except Exception:
            sas_url = api_resp.text.strip().strip('"')
    except Exception as e:
        print(f"[stahování] Chyba při získávání SAS URL: {e}")
        return None

    if not sas_url or not sas_url.startswith("http"):
        print(f"[stahování] Neplatná SAS URL: {str(sas_url)[:100]}")
        return None

    # Stáhni ZIP z Azure Blob Storage
    print(f"[stahování] Stahuji {zip_filename}...")
    try:
        zip_resp = requests.get(sas_url, timeout=60)
        zip_resp.raise_for_status()
    except Exception as e:
        print(f"[stahování] Chyba při stahování ZIP: {e}")
        return None

    # Rozbal Lh7
    try:
        with zipfile.ZipFile(io.BytesIO(zip_resp.content)) as zf:
            lh7_names = [n for n in zf.namelist() if n.lower().endswith(".lh7")]
            if not lh7_names:
                print("[stahování] ZIP neobsahuje .Lh7 soubor")
                return None
            dest = os.path.join(IMPORT_DIR, os.path.basename(lh7_names[0]))
            os.makedirs(IMPORT_DIR, exist_ok=True)
            with zf.open(lh7_names[0]) as src, open(dest, "wb") as out:
                out.write(src.read())
    except Exception as e:
        print(f"[stahování] Chyba při rozbalování: {e}")
        return None

    print(f"[stahování] Rozbaleno: {os.path.basename(dest)} ({os.path.getsize(dest):,} B)")
    return dest


def find_latest_file() -> str:
    files = glob.glob(os.path.join(IMPORT_DIR, "*.Lh7"))
    if not files:
        raise FileNotFoundError(f"Žádný *.Lh7 soubor nenalezen v {IMPORT_DIR}")
    return max(files, key=os.path.getmtime)


def import_file(filepath: str, conn: mysql.connector.MySQLConnection) -> int:
    cursor = conn.cursor()
    cursor.execute("DROP TABLE IF EXISTS vzp_pracoviste")
    cursor.execute(CREATE_TABLE_SQL)
    conn.commit()

    insert_sql = """
        INSERT INTO vzp_pracoviste
            (ico, icz, icp, odbornost, platnost_od, platnost_do,
             nazev_zarizeni, nazev_pracoviste, ulice, mesto, psc)
        VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
    """

    batch = []
    total = 0
    skipped = 0

    with open(filepath, encoding="cp1250", errors="replace", newline="") as f:
        reader = csv.reader(f, quotechar='"', skipinitialspace=True)
        for row in reader:
            if len(row) < 10:
                skipped += 1
                continue

            platnost_od = parse_date(row[4])
            platnost_do = parse_date(row[5])
            if platnost_od is None or platnost_do is None:
                skipped += 1
                continue

            # ulice = název ulice + číslo popisné + číslo orientační (sloupce 11,12,13)
            ulice_parts = [row[11].strip(), row[12].strip(), row[13].strip()] if len(row) > 13 else []
            ulice = " ".join(p for p in ulice_parts if p) or row[8].strip()

            psc = row[14].strip() if len(row) > 14 else ""
            if len(psc) > 5:
                psc = psc[:5]

            batch.append((
                row[0].strip(),   # ico
                row[1].strip(),   # icz
                row[2].strip(),   # icp
                row[3].strip(),   # odbornost
                platnost_od,
                platnost_do,
                row[6].strip()[:200] if len(row) > 6 else "",   # nazev_zarizeni
                row[7].strip()[:200] if len(row) > 7 else "",   # nazev_pracoviste
                ulice[:150],
                row[9].strip()[:100] if len(row) > 9 else "",   # mesto
                psc,
            ))

            if len(batch) >= BATCH_SIZE:
                cursor.executemany(insert_sql, batch)
                conn.commit()
                total += len(batch)
                batch.clear()

    if batch:
        cursor.executemany(insert_sql, batch)
        conn.commit()
        total += len(batch)

    cursor.close()
    return total, skipped


def main():
    args = sys.argv[1:]
    no_download = "--no-download" in args
    args = [a for a in args if a != "--no-download"]

    if args:
        filepath = args[0]
    else:
        if not no_download:
            downloaded = download_latest_file()
            if downloaded is None:
                print("[stahování] Pokračuji s lokálním souborem...")
        filepath = find_latest_file()

    filename = os.path.basename(filepath)

    print(f"Soubor:    {filename}")
    print(f"Databáze:  {DB_CONFIG['host']}/{DB_CONFIG['database']}")
    print(f"Začátek:   {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

    conn = mysql.connector.connect(**DB_CONFIG)
    try:
        total, skipped = import_file(filepath, conn)
    finally:
        conn.close()

    print(f"Importováno: {total} záznamů")
    if skipped:
        print(f"Přeskočeno:  {skipped} řádků (neúplná data)")
    print(f"Hotovo:    {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")


if __name__ == "__main__":
    main()