her-sync 0.3.0__py3-none-any.whl

her_sync/__init__.py

@@ -0,0 +1,3 @@
+"""her-sync: Linux-native Sync-Tool für Agent-Share-Filesysteme."""
+
+__version__ = "0.1.0"

her_sync/__main__.py

@@ -0,0 +1,3 @@
+from her_sync.cli import app
+
+app()

her_sync/apply/__init__.py

@@ -0,0 +1,8 @@
+from her_sync.apply.cost_centers import apply_cost_center_assignments
+from her_sync.apply.invoices import apply_invoice_actions, plan_invoice_actions
+
+__all__ = [
+    "apply_cost_center_assignments",
+    "apply_invoice_actions",
+    "plan_invoice_actions",
+]

her_sync/apply/cost_centers.py

@@ -0,0 +1,84 @@
+"""Kostenstellenzuordnung aus Agent-Ergebnissen anwenden."""
+
+from __future__ import annotations
+
+from her_sync.bde.cashflows import CashflowService
+from her_sync.bde.cost_centers import load_cost_center_map
+from her_sync.bde.session import BdeSession
+from her_sync.config import BdeSettings
+from her_sync.io.xlsx import read_rows
+from her_sync.share.layout import ShareLayout
+
+
+def apply_cost_center_assignments(
+    settings: BdeSettings,
+    layout: ShareLayout,
+    *,
+    dry_run: bool = False,
+) -> list[tuple[int, str]]:
+    """Liest extract.xlsx und ordnet Kostenstellen zu.
+
+    Abbruch wenn Belegnr + Rechnungsdatum nicht eindeutig identifizierbar.
+    Gibt Liste der durchgeführten Zuordnungen zurück.
+    """
+    if not layout.extract_results.exists():
+        raise FileNotFoundError(f"Keine Agent-Ergebnisse: {layout.extract_results}")
+
+    rows = read_rows(layout.extract_results)
+    assignments: dict[int, str] = {}
+
+    for row in rows:
+        if row.get("status") != "complete":
+            continue
+        cf_id = row.get("cashflow_id")
+        cost_center = row.get("cost_center_ident")
+        invoice_number = row.get("invoice_number")
+        invoice_date = row.get("invoice_date")
+
+        if not cf_id or not cost_center:
+            continue
+
+        # Eindeutigkeit: Belegnr UND Rechnungsdatum müssen gesetzt sein
+        if not invoice_number or not invoice_date:
+            raise ValueError(
+                f"Zeile ohne eindeutige Identifikation (Belegnr+Datum): "
+                f"cashflow_id={cf_id}, file={row.get('relative_file_path')}"
+            )
+
+        cf_id = int(cf_id)
+        if cf_id in assignments and assignments[cf_id] != cost_center:
+            raise ValueError(
+                f"Widersprüchliche Kostenstelle für cashflow {cf_id}: "
+                f"{assignments[cf_id]} vs {cost_center}"
+            )
+        assignments[cf_id] = str(cost_center)
+
+    if dry_run:
+        return [(cf_id, cc) for cf_id, cc in assignments.items()]
+
+    cookie_file = settings.bde_cookie_file()
+    applied: list[tuple[int, str]] = []
+
+    with BdeSession(
+        base_url=settings.bde_base_url,
+        basic_user=settings.bde_basic_auth_user,
+        basic_pass=settings.bde_basic_auth_pass,
+        login=settings.bde_login,
+        password=settings.bde_password,
+        cookie_file=cookie_file,
+    ) as session:
+        session.ensure_logged_in()
+        service = CashflowService(session, settings.bde_company_id)
+
+        # cost_center_id Lookup — hier Platzhalter: Mapping aus Config oder BDE-Abfrage nötig
+        # TODO: cost_center ident -> id mapping aus BDE laden
+        cost_center_map = load_cost_center_map(session, settings.bde_company_id)
+
+        for cf_id, ident in assignments.items():
+            cc_id = cost_center_map.get(ident)
+            if cc_id is None:
+                raise ValueError(f"Unbekannte Kostenstelle: {ident}")
+            service.assign_cost_center([cf_id], cc_id)
+            applied.append((cf_id, ident))
+
+    return applied

her_sync/apply/invoices.py

@@ -0,0 +1,77 @@
+"""Rechnungszuordnung und -erstellung aus Agent-Ergebnissen."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from her_sync.config import BdeSettings
+from her_sync.io.xlsx import read_rows
+from her_sync.share.layout import ShareLayout
+
+
+@dataclass
+class ApplyPlan:
+    """Geplante Aktionen vor Ausführung — für Review/Dry-Run."""
+
+    match_existing: list[dict]
+    create_new: list[dict]
+    skipped_incomplete: list[dict]
+    aborted_conflicts: list[dict]
+
+
+def plan_invoice_actions(settings: BdeSettings, layout: ShareLayout) -> ApplyPlan:
+    """Plant Rechnungsaktionen ohne Ausführung.
+
+    Regeln:
+    - status=incomplete -> überspringen
+    - Belegnr + Rechnungsdatum müssen für Auto-Zuordnung vorhanden sein
+    - Abweichung bei bestehender Rechnung -> Konflikt, abbrechen
+    """
+    if not layout.extract_results.exists():
+        raise FileNotFoundError(f"Keine Agent-Ergebnisse: {layout.extract_results}")
+
+    rows = read_rows(layout.extract_results)
+    match_existing: list[dict] = []
+    create_new: list[dict] = []
+    skipped: list[dict] = []
+    conflicts: list[dict] = []
+
+    for row in rows:
+        if row.get("status") == "incomplete":
+            skipped.append(row)
+            continue
+
+        invoice_number = row.get("invoice_number")
+        invoice_date = row.get("invoice_date")
+        if not invoice_number or not invoice_date:
+            skipped.append(row)
+            continue
+
+        if row.get("cashflow_id"):
+            create_new.append(row)
+        else:
+            match_existing.append(row)
+
+    return ApplyPlan(
+        match_existing=match_existing,
+        create_new=create_new,
+        skipped_incomplete=skipped,
+        aborted_conflicts=conflicts,
+    )
+
+
+def apply_invoice_actions(settings: BdeSettings, layout: ShareLayout, *, dry_run: bool = False) -> ApplyPlan:
+    """Führt geplante Rechnungsaktionen aus. Bei Abweichung sofort abbrechen."""
+    plan = plan_invoice_actions(settings, layout)
+    if dry_run:
+        return plan
+
+    # TODO: Implementierung nach Browser-Recording der Invoice-Forms
+    # - GET /companies/1/invoices?invoicable_type=Creditor&type=new
+    # - Upload businessattachments
+    # - POST update mit extrahierten Feldern
+    # - create_invoice aus übrigen cashflows
+    raise NotImplementedError(
+        "Invoice-Apply benötigt Browser-Recording der Formularfelder — "
+        "Browser-Recording (dev): playwright + manuelle Aufzeichnung nötig"
+    )

her_sync/bde/__init__.py

@@ -0,0 +1,11 @@
+from her_sync.bde.cashflows import CashflowRow, CashflowService
+from her_sync.bde.invoices import InvoiceRow, InvoiceService
+from her_sync.bde.session import BdeSession
+
+__all__ = [
+    "BdeSession",
+    "CashflowRow",
+    "CashflowService",
+    "InvoiceRow",
+    "InvoiceService",
+]

her_sync/bde/cashflows.py

@@ -0,0 +1,150 @@
+"""BDE Cashflow-Operationen."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, datetime, timedelta
+
+from bs4 import BeautifulSoup
+
+from her_sync.bde.session import BdeSession
+
+HISTORY_REASON = "Keiner"
+
+
+@dataclass
+class CashflowRow:
+    id: int
+    amount: float
+    valid_date: date
+    reason: str
+    cost_center_ident: str | None
+    assigned_invoice_ids: list[int]
+    splitted: bool
+    cash_payment: bool
+
+
+class CashflowService:
+    def __init__(self, session: BdeSession, company_id: int):
+        self.session = session
+        self.company_id = company_id
+
+    def fetch_no_cost_center(self) -> list[CashflowRow]:
+        path = self.session.company_path(self.company_id, "cashflows?type=no_cost_center")
+        resp = self.session.client.get(path)
+        resp.raise_for_status()
+        return self._parse_cashflow_table(resp.text)
+
+    def fetch_history(self, months: int = 3, *, timeout: float = 300.0) -> list[CashflowRow]:
+        """Cashflows der letzten N Monate (type=all, client-seitig filtern).
+
+        BDE liefert alle Buchungen in einer HTML-Tabelle — kann bei großen
+        Datenmengen dauern (daher längeres Timeout).
+        """
+        cutoff = date.today() - timedelta(days=months * 31)
+        path = self.session.company_path(self.company_id, "cashflows?type=all")
+        resp = self.session.client.get(path, timeout=timeout)
+        resp.raise_for_status()
+        rows = self._parse_cashflow_table(resp.text)
+        return [r for r in rows if r.valid_date >= cutoff]
+
+    @staticmethod
+    def _is_keiner_reason(reason: str) -> bool:
+        return reason.strip() in ("", HISTORY_REASON)
+
+    @classmethod
+    def filter_history_patterns(cls, rows: list[CashflowRow]) -> list[CashflowRow]:
+        """Buchungen für Kostenstellen-Muster (nicht gesplittet, keine Barzahlung)."""
+        return [
+            r
+            for r in rows
+            if not r.splitted
+            and not r.cash_payment
+            and not cls._is_keiner_reason(r.reason)
+            and r.cost_center_ident
+        ]
+
+    def assign_cost_center(
+        self,
+        cashflow_ids: list[int],
+        cost_center_id: int,
+        list_type: str = "no_cost_center",
+    ) -> None:
+        path = self.session.company_path(self.company_id, "cashflows/cashflow-assign")
+        token = self.session.get_authenticity_token(
+            self.session.company_path(self.company_id, f"cashflows?type={list_type}")
+        )
+
+        data: dict[str, str] = {
+            "authenticity_token": token,
+            "type": list_type,
+            "cost_center_id": str(cost_center_id),
+            "assign": "Kostenstelle zuordnen",
+        }
+        for cf_id in cashflow_ids:
+            data[f"cashflows[{cf_id}][selected]"] = "1"
+
+        resp = self.session.client.post(path, data=data)
+        resp.raise_for_status()
+
+    @staticmethod
+    def _parse_cashflow_table(html: str) -> list[CashflowRow]:
+        soup = BeautifulSoup(html, "lxml")
+        rows: list[CashflowRow] = []
+
+        for tr in soup.select("table tbody tr"):
+            checkbox = tr.find("input", {"type": "checkbox"})
+            if not checkbox or not checkbox.get("name"):
+                continue
+
+            name = checkbox["name"]
+            # cashflows[24592][selected]
+            cf_id = int(name.split("[")[1].split("]")[0])
+            cells = tr.find_all("td")
+            if len(cells) < 5:
+                continue
+
+            assigned_links = tr.select("a[href*='/invoices/']")
+            invoice_ids = []
+            for link in assigned_links:
+                href = link.get("href", "")
+                if "/invoices/" in href:
+                    try:
+                        invoice_ids.append(int(href.split("/invoices/")[1].split("/")[0]))
+                    except ValueError:
+                        pass
+
+            amount_text = cells[2].get_text(strip=True).replace(",", ".")
+            try:
+                amount = float(amount_text)
+            except ValueError:
+                amount = 0.0
+
+            date_text = cells[3].get_text(strip=True)
+            try:
+                valid_date = datetime.strptime(date_text, "%Y-%m-%d").date()
+            except ValueError:
+                valid_date = date.today()
+
+            cost_center = cells[4].get_text(strip=True)
+            if cost_center in ("Keine", "-", ""):
+                cost_center = None
+
+            reason = cells[5].get_text(strip=True) if len(cells) > 5 else ""
+            splitted = "Gesplittet" in tr.get_text()
+            cash_payment = "BARZAHLUNG" in tr.get_text()
+
+            rows.append(
+                CashflowRow(
+                    id=cf_id,
+                    amount=amount,
+                    valid_date=valid_date,
+                    reason=reason,
+                    cost_center_ident=cost_center,
+                    assigned_invoice_ids=invoice_ids,
+                    splitted=splitted,
+                    cash_payment=cash_payment,
+                )
+            )
+
+        return rows

her_sync/bde/cost_centers.py

@@ -0,0 +1,22 @@
+"""BDE Kostenstellen-Lookup."""
+
+from __future__ import annotations
+
+from bs4 import BeautifulSoup
+
+from her_sync.bde.session import BdeSession
+
+
+def load_cost_center_map(session: BdeSession, company_id: int) -> dict[str, int]:
+    """Kostenstellen-Ident → ID aus HTML-Select laden."""
+    path = session.company_path(company_id, "cashflows?type=no_cost_center")
+    resp = session.client.get(path)
+    resp.raise_for_status()
+    soup = BeautifulSoup(resp.text, "lxml")
+    mapping: dict[str, int] = {}
+    for opt in soup.select("select[name='cost_center_id'] option"):
+        value = opt.get("value")
+        ident = opt.get_text(strip=True)
+        if value and value.isdigit() and ident:
+            mapping[ident] = int(value)
+    return mapping

her_sync/bde/invoices.py

@@ -0,0 +1,199 @@
+"""BDE Rechnungs-Operationen."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, datetime
+
+from bs4 import BeautifulSoup
+
+from her_sync.bde.session import BdeSession
+
+
+@dataclass
+class InvoiceRow:
+    id: int
+    invoice_number: str | None
+    invoice_date: date | None
+    due_date: date | None
+    amount: float | None
+    creditor_name: str
+    state: str
+    has_bookings: bool
+    booking_ids: list[int]
+    has_receipts: bool
+    receipt_count: int
+
+
+class InvoiceService:
+    def __init__(self, session: BdeSession, company_id: int):
+        self.session = session
+        self.company_id = company_id
+
+    def fetch_creditor_invoices(self, state: str = "new") -> list[InvoiceRow]:
+        path = self.session.company_path(
+            self.company_id,
+            f"invoices?invoicable_type=Creditor&type={state}",
+        )
+        resp = self.session.client.get(path)
+        resp.raise_for_status()
+        return self._parse_invoice_list(resp.text, state)
+
+    def fetch_all_open_creditor(self) -> list[InvoiceRow]:
+        """Alle offenen Kreditorenrechnungen (type=new + type=booked)."""
+        seen: set[int] = set()
+        result: list[InvoiceRow] = []
+        for state in ("new", "booked"):
+            for inv in self.fetch_creditor_invoices(state):
+                if inv.id in seen:
+                    continue
+                seen.add(inv.id)
+                result.append(inv)
+        return result
+
+    def fetch_creditor_name(self, invoice_id: int) -> str:
+        """Kreditor aus Rechnungsdetailseite (Text nach „Ziel:“)."""
+        path = self.session.company_path(self.company_id, f"invoices/{invoice_id}")
+        resp = self.session.client.get(path)
+        resp.raise_for_status()
+        return self._parse_creditor_from_detail(resp.text)
+
+    def fetch_open_gaps(self) -> list[InvoiceRow]:
+        """Kombiniert new + booked und filtert Lücken."""
+        seen: set[int] = set()
+        result: list[InvoiceRow] = []
+        for state in ("new", "booked"):
+            for inv in self.fetch_creditor_invoices(state):
+                if inv.id in seen:
+                    continue
+                seen.add(inv.id)
+                if self._has_gap(inv):
+                    result.append(inv)
+        return result
+
+    @staticmethod
+    def _has_gap(inv: InvoiceRow) -> bool:
+        has_bookings = inv.has_bookings
+        has_receipts = inv.has_receipts
+        if has_bookings and not has_receipts:
+            return True
+        if has_receipts and not has_bookings:
+            return True
+        if has_bookings and has_receipts and inv.receipt_count == 0:
+            return True
+        return False
+
+    @staticmethod
+    def gap_type(inv: InvoiceRow) -> str:
+        if inv.has_bookings and not inv.has_receipts:
+            return "missing_receipt"
+        if inv.has_receipts and not inv.has_bookings:
+            return "missing_booking"
+        if inv.has_bookings and inv.has_receipts:
+            return "partial_both"
+        return "unknown"
+
+    @staticmethod
+    def _parse_invoice_list(html: str, state: str) -> list[InvoiceRow]:
+        soup = BeautifulSoup(html, "lxml")
+        rows: list[InvoiceRow] = []
+
+        for tr in soup.select("table tbody tr"):
+            link = tr.find("a", href=lambda h: h and "/invoices/" in h and "/edit" not in h)
+            if not link:
+                continue
+
+            href = link["href"]
+            try:
+                inv_id = int(href.split("/invoices/")[1].split("/")[0].split("?")[0])
+            except (IndexError, ValueError):
+                continue
+
+            cells = tr.find_all("td")
+            if len(cells) < 4:
+                continue
+
+            invoice_number = cells[0].get_text(" ", strip=True) or None
+            creditor_name = cells[1].get_text(" ", strip=True)
+            amount_text = cells[2].get_text(strip=True).replace(",", ".")
+            date_text = cells[3].get_text(strip=True)
+            row_state = cells[4].get_text(strip=True) if len(cells) > 4 else state
+
+            try:
+                amount = float(amount_text)
+            except ValueError:
+                amount = _extract_amount(tr.get_text(" ", strip=True))
+
+            invoice_date = _parse_date_text(date_text) or _extract_date(tr.get_text(" ", strip=True))
+            text = tr.get_text(" ", strip=True)
+
+            rows.append(
+                InvoiceRow(
+                    id=inv_id,
+                    invoice_number=invoice_number,
+                    invoice_date=invoice_date,
+                    due_date=None,
+                    amount=amount,
+                    creditor_name=creditor_name,
+                    state=row_state or state,
+                    has_bookings="Buchung" in text or "cashflow" in text.lower(),
+                    booking_ids=[],
+                    has_receipts="Anhang" in text or "Beleg" in text or "attachment" in text.lower(),
+                    receipt_count=text.lower().count("anhang") + text.lower().count("beleg"),
+                )
+            )
+
+        return rows
+
+    @staticmethod
+    def _parse_creditor_from_detail(html: str) -> str:
+        import re
+
+        soup = BeautifulSoup(html, "lxml")
+        for node in soup.find_all(string=re.compile(r"Ziel\s*:")):
+            text = str(node).strip()
+            if text.startswith("Ziel:"):
+                return text.split(":", 1)[1].strip()
+            parent = node.parent
+            if parent:
+                full = parent.get_text(" ", strip=True)
+                if "Ziel:" in full:
+                    return full.split("Ziel:", 1)[1].strip()
+        match = re.search(r"Ziel:\s*(.+?)(?:\n|$)", soup.get_text("\n"))
+        return match.group(1).strip() if match else ""
+
+
+def _parse_date_text(value: str) -> date | None:
+    value = value.strip()
+    for fmt in ("%d.%m.%Y", "%Y-%m-%d"):
+        try:
+            return datetime.strptime(value, fmt).date()
+        except ValueError:
+            continue
+    return None
+
+
+def _extract_date(text: str) -> date | None:
+    import re
+
+    for fmt in ("%Y-%m-%d", "%d.%m.%Y"):
+        for match in re.findall(r"\d{4}-\d{2}-\d{2}|\d{2}\.\d{2}\.\d{4}", text):
+            try:
+                return datetime.strptime(match, fmt).date()
+            except ValueError:
+                continue
+    return None
+
+
+def _extract_amount(text: str) -> float | None:
+    import re
+
+    match = re.search(r"(-?\d+[.,]\d{2})", text)
+    if match:
+        return float(match.group(1).replace(",", "."))
+    return None
+
+
+def _extract_creditor(text: str) -> str:
+    # Heuristik — wird beim Browser-Recording verfeinert
+    return ""

her_sync/bde/session.py

@@ -0,0 +1,124 @@
+"""BDE Session-Handling: Basic-Auth + POST-Login + Cookie."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import httpx
+from bs4 import BeautifulSoup
+
+
+class BdeSession:
+    """HTTP-Client mit BDE-Authentifizierung."""
+
+    def __init__(
+        self,
+        base_url: str,
+        basic_user: str = "",
+        basic_pass: str = "",
+        login: str = "",
+        password: str = "",
+        cookie_file: Path | None = None,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.login = login
+        self.password = password
+        self.cookie_file = cookie_file
+
+        auth = (basic_user, basic_pass) if basic_user else None
+        self.client = httpx.Client(
+            base_url=self.base_url,
+            auth=auth,
+            follow_redirects=True,
+            timeout=60.0,
+            headers={"User-Agent": "her-sync/0.2"},
+        )
+
+        if cookie_file and cookie_file.exists():
+            self._load_cookies()
+
+    def _clear_cookies(self) -> None:
+        self.client.cookies.clear()
+        if self.cookie_file and self.cookie_file.exists():
+            self.cookie_file.unlink()
+
+    def _load_cookies(self) -> None:
+        import json
+
+        data = json.loads(self.cookie_file.read_text())
+        for name, value in data.items():
+            self.client.cookies.set(name, value)
+
+    def _save_cookies(self) -> None:
+        if not self.cookie_file:
+            return
+        import json
+
+        self.cookie_file.parent.mkdir(parents=True, exist_ok=True)
+        cookies = {c.name: c.value for c in self.client.cookies.jar}
+        self.cookie_file.write_text(json.dumps(cookies, indent=2))
+
+    def login_post(self) -> bool:
+        """POST /session mit login/password."""
+        resp = self.client.get("/session/new")
+        token = self._extract_authenticity_token(resp.text)
+
+        data = {
+            "login": self.login,
+            "password": self.password,
+            "commit": "Login",
+        }
+        if token:
+            data["authenticity_token"] = token
+
+        resp = self.client.post("/session", data=data)
+        self._save_cookies()
+        return self._is_logged_in(resp)
+
+    def ensure_logged_in(self) -> None:
+        resp = self.client.get("/")
+        if not self._is_logged_in(resp):
+            self._clear_cookies()
+            if not self.login_post():
+                raise RuntimeError("BDE-Login fehlgeschlagen — Credentials prüfen")
+
+    @staticmethod
+    def _is_logged_in(resp: httpx.Response) -> bool:
+        if resp.status_code == 401:
+            return False
+        url = str(resp.url)
+        if "/session/new" in url:
+            return False
+        if "fehlgeschlagen" in resp.text.lower():
+            return False
+        return True
+
+    @staticmethod
+    def _extract_authenticity_token(html: str) -> str | None:
+        soup = BeautifulSoup(html, "lxml")
+        tag = soup.find("input", {"name": "authenticity_token"})
+        if tag and tag.get("value"):
+            return tag["value"]
+        match = re.search(r'name="authenticity_token"\s+value="([^"]+)"', html)
+        return match.group(1) if match else None
+
+    def get_authenticity_token(self, path: str) -> str:
+        resp = self.client.get(path)
+        resp.raise_for_status()
+        token = self._extract_authenticity_token(resp.text)
+        if not token:
+            raise RuntimeError(f"Kein authenticity_token auf {path}")
+        return token
+
+    def company_path(self, company_id: int, subpath: str) -> str:
+        return f"/companies/{company_id}/{subpath.lstrip('/')}"
+
+    def close(self) -> None:
+        self.client.close()
+
+    def __enter__(self) -> BdeSession:
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()