697 lines
33 KiB
Python
697 lines
33 KiB
Python
# Copyright (c) 2025 Patrick Motsch
|
||
# All rights reserved.
|
||
"""Run My Accounts (Infoniqa) accounting connector.
|
||
|
||
API docs: https://runmyaccountsag.github.io/runmyaccounts-rest-api/
|
||
Auth: PAT tokens (``pat_...``) via ``Authorization: Bearer``.
|
||
Fallback for legacy API keys via ``X-RMA-KEY``.
|
||
Base URL: https://service.runmyaccounts.com/api/latest/clients/{clientName}/
|
||
"""
|
||
|
||
import asyncio
|
||
import json
|
||
import logging
|
||
import re
|
||
from datetime import datetime
|
||
from typing import List, Dict, Any, Optional
|
||
|
||
import aiohttp
|
||
|
||
from ..accountingConnectorBase import (
|
||
BaseAccountingConnector,
|
||
AccountingBooking,
|
||
AccountingChart,
|
||
ConnectorConfigField,
|
||
SyncResult,
|
||
)
|
||
from modules.shared.i18nRegistry import t
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
_DEFAULT_API_BASE_URL = "https://service.runmyaccounts.com/api/latest/clients/"
|
||
|
||
|
||
class AccountingConnectorRma(BaseAccountingConnector):
|
||
|
||
def getConnectorType(self) -> str:
|
||
return "rma"
|
||
|
||
def getConnectorLabel(self) -> str:
|
||
return "Run My Accounts"
|
||
|
||
def getRequiredConfigFields(self) -> List[ConnectorConfigField]:
|
||
return [
|
||
ConnectorConfigField(
|
||
key="apiBaseUrl",
|
||
label=t("API Base URL"),
|
||
fieldType="text",
|
||
secret=False,
|
||
placeholder="https://service.runmyaccounts.com/api/latest/clients/",
|
||
),
|
||
ConnectorConfigField(
|
||
key="clientName",
|
||
label=t("Mandantenname"),
|
||
fieldType="text",
|
||
secret=False,
|
||
placeholder="e.g. meinefirma",
|
||
),
|
||
ConnectorConfigField(
|
||
key="apiKey",
|
||
label=t("API-Schlüssel"),
|
||
fieldType="password",
|
||
secret=True,
|
||
),
|
||
]
|
||
|
||
def _buildUrl(self, config: Dict[str, Any], resource: str) -> str:
|
||
apiBaseUrl = str(config.get("apiBaseUrl") or "").strip()
|
||
if not apiBaseUrl:
|
||
raise ValueError("Missing required config: apiBaseUrl")
|
||
apiBaseUrl = apiBaseUrl.rstrip("/") + "/"
|
||
|
||
clientName = str(config.get("clientName") or "").strip()
|
||
if not clientName:
|
||
raise ValueError("Missing required config: clientName")
|
||
return f"{apiBaseUrl}{clientName}/{resource}"
|
||
|
||
def _buildHeaders(self, config: Dict[str, Any]) -> Dict[str, str]:
|
||
apiKey = config.get("apiKey", "")
|
||
headers = {
|
||
"Accept": "application/json, application/xml, */*",
|
||
"Content-Type": "application/json",
|
||
}
|
||
if str(apiKey).startswith("pat_"):
|
||
headers["Authorization"] = f"Bearer {apiKey}"
|
||
else:
|
||
headers["X-RMA-KEY"] = apiKey
|
||
return headers
|
||
|
||
async def testConnection(self, config: Dict[str, Any]) -> SyncResult:
|
||
clientName = config.get("clientName", "")
|
||
apiKey = config.get("apiKey", "")
|
||
|
||
apiBaseUrl = str(config.get("apiBaseUrl") or "")
|
||
if not clientName or not apiKey or not apiBaseUrl:
|
||
return SyncResult(
|
||
success=False,
|
||
errorMessage=(
|
||
f"Missing credentials: apiBaseUrl={bool(apiBaseUrl)}, "
|
||
f"clientName={bool(clientName)}, apiKey={bool(apiKey)}"
|
||
),
|
||
)
|
||
|
||
url = self._buildUrl(config, "customers")
|
||
headers = self._buildHeaders(config)
|
||
authMethod = "Bearer" if str(apiKey).startswith("pat_") else "X-RMA-KEY"
|
||
logger.info(
|
||
"RMA testConnection: url=%s, clientName=%s, apiKey=%s..., auth=%s",
|
||
url, clientName, apiKey[:6] if len(apiKey) > 6 else "***", authMethod,
|
||
)
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get(url, headers=headers, timeout=aiohttp.ClientTimeout(total=15)) as resp:
|
||
if resp.status == 200:
|
||
logger.info("RMA connection successful with auth method: %s", authMethod)
|
||
return SyncResult(success=True, rawResponse={"authMethod": authMethod})
|
||
body = await resp.text()
|
||
logger.warning("RMA testConnection failed: status=%s, url=%s, body=%s", resp.status, url, body[:500])
|
||
return SyncResult(success=False, errorMessage=f"HTTP {resp.status}: {body[:300]}")
|
||
except Exception as e:
|
||
return SyncResult(success=False, errorMessage=str(e))
|
||
|
||
def _rmaLinkToAccountType(self, link: str) -> str:
|
||
"""Map RMA chart 'link' (e.g. AP_amount, AR_amount, AR_paid:AP_paid) to our accountType."""
|
||
if not link:
|
||
return ""
|
||
linkUpper = link.upper()
|
||
if "AP_AMOUNT" in linkUpper:
|
||
return "expense"
|
||
if "AR_AMOUNT" in linkUpper:
|
||
return "revenue"
|
||
if "AR_PAID" in linkUpper or "AP_PAID" in linkUpper:
|
||
return "asset"
|
||
if "AR_TAX" in linkUpper or "AP_TAX" in linkUpper:
|
||
return "liability"
|
||
if linkUpper in ("AR", "AP"):
|
||
return "asset"
|
||
return link
|
||
|
||
async def getChartOfAccounts(self, config: Dict[str, Any], accountType: Optional[str] = None) -> List[AccountingChart]:
|
||
"""RMA API 'type' filter expects RMA values (AP_amount, AR_amount, etc.), not 'expense'. Fetch full chart and filter client-side."""
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
url = self._buildUrl(config, "charts")
|
||
async with session.get(url, headers=self._buildHeaders(config), timeout=aiohttp.ClientTimeout(total=30)) as resp:
|
||
if resp.status != 200:
|
||
body = await resp.text()
|
||
logger.error(f"RMA charts failed: HTTP {resp.status} - {body[:200]}")
|
||
return []
|
||
data = await resp.json()
|
||
|
||
charts = []
|
||
items = data if isinstance(data, list) else data.get("chart", data.get("row", []))
|
||
if not isinstance(items, list):
|
||
items = [items] if isinstance(items, dict) else []
|
||
for item in items:
|
||
if isinstance(item, dict):
|
||
accNo = str(item.get("accno") or item.get("account_number") or item.get("number") or item.get("@accno") or "")
|
||
label = str(item.get("description") or item.get("label") or item.get("@description") or "")
|
||
rmaLink = item.get("link") or ""
|
||
chartType = item.get("charttype") or item.get("category") or ""
|
||
if not chartType and rmaLink:
|
||
chartType = self._rmaLinkToAccountType(rmaLink)
|
||
if not chartType and accNo:
|
||
firstDigit = accNo[0] if accNo else ""
|
||
chartType = {
|
||
"1": "asset", "2": "liability", "3": "revenue",
|
||
"4": "expense", "5": "expense", "6": "expense",
|
||
"7": "expense", "8": "expense", "9": "closing",
|
||
}.get(firstDigit, "")
|
||
charts.append(AccountingChart(accountNumber=accNo, label=label, accountType=chartType))
|
||
return charts
|
||
except Exception as e:
|
||
logger.error(f"RMA getChartOfAccounts error: {e}")
|
||
return []
|
||
|
||
async def pushBooking(self, config: Dict[str, Any], booking: AccountingBooking) -> SyncResult:
|
||
"""Push a GL batch booking to RMA. API expects request body = batch object (no wrapper); only non-zero amount per line."""
|
||
try:
|
||
if not booking.lines:
|
||
return SyncResult(success=False, errorMessage="Missing transactions in batch (no booking lines)")
|
||
|
||
glTransactions = []
|
||
for line in booking.lines:
|
||
t = {"accno": line.accountNumber}
|
||
if line.debitAmount and line.debitAmount > 0:
|
||
t["debit_amount"] = line.debitAmount
|
||
if line.creditAmount and line.creditAmount > 0:
|
||
t["credit_amount"] = line.creditAmount
|
||
if line.description:
|
||
t["memo"] = (line.description or "")[:500]
|
||
glTransactions.append(t)
|
||
|
||
transdate = booking.bookingDate or ""
|
||
if transdate and "T" not in str(transdate):
|
||
transdate = f"{transdate}T00:00:00.000+00:00"
|
||
batchNumber = (booking.reference or "").strip()[:32]
|
||
if not batchNumber:
|
||
batchNumber = "GL-" + (booking.reference or str(id(booking)))[:24]
|
||
rawDesc = (booking.description or "").strip()
|
||
externalDocIds = getattr(booking, "externalDocumentIds", None) or []
|
||
externalDocLabels = getattr(booking, "externalDocumentLabels", None) or []
|
||
if externalDocIds or externalDocLabels:
|
||
clientSegment = (config.get("clientId") or config.get("clientName") or "").strip()
|
||
docParts = []
|
||
maxI = max(len(externalDocIds), len(externalDocLabels))
|
||
for i in range(min(maxI, 10)):
|
||
label = (externalDocLabels[i] if i < len(externalDocLabels) else "Rechnung") or "Rechnung"
|
||
belegId = externalDocIds[i] if i < len(externalDocIds) else None
|
||
if belegId:
|
||
docUrl = f"https://my.runmyaccounts.com/phoenix-core/api/clients/{clientSegment}/workflow/l0doc/file/{belegId}"
|
||
docParts.append(f'<a href="{docUrl}">{label}</a>')
|
||
else:
|
||
docParts.append(label)
|
||
erfDate = datetime.utcnow().strftime("%d.%m.%Y")
|
||
linkSuffix = " (" + ", ".join(docParts) + ", erf. " + erfDate + ")"
|
||
shortDesc = (rawDesc[:80] + "...") if len(rawDesc) > 80 else rawDesc
|
||
description = (shortDesc + linkSuffix).strip()[:500]
|
||
else:
|
||
description = rawDesc[:500]
|
||
payload = {
|
||
"batch_number": batchNumber,
|
||
"transdate": transdate,
|
||
"description": description,
|
||
"currency": "CHF",
|
||
"exchangerate": 1.0,
|
||
"gl_transactions": {"gl_transaction": glTransactions},
|
||
}
|
||
if rawDesc and len(rawDesc) > 80:
|
||
payload["notes"] = rawDesc[:2000]
|
||
|
||
logger.debug("RMA pushBooking payload: batch=%s transdate=%s accounts=%s",
|
||
batchNumber, transdate,
|
||
[(t.get("accno"), t.get("debit_amount"), t.get("credit_amount")) for t in glTransactions])
|
||
|
||
async with aiohttp.ClientSession() as session:
|
||
url = self._buildUrl(config, "gl")
|
||
async with session.post(url, headers=self._buildHeaders(config), json=payload, timeout=aiohttp.ClientTimeout(total=30)) as resp:
|
||
body = await resp.text()
|
||
if resp.status in (200, 201, 204):
|
||
externalId = None
|
||
try:
|
||
data = json.loads(body) if body.strip() else {}
|
||
if isinstance(data, dict):
|
||
externalId = (
|
||
data.get("id")
|
||
or data.get("batch_id")
|
||
or data.get("entry_id")
|
||
or (data.get("gl_batch") or {}).get("id")
|
||
)
|
||
if externalId is not None:
|
||
externalId = str(externalId).strip()
|
||
if not externalId:
|
||
externalId = batchNumber
|
||
except Exception:
|
||
externalId = batchNumber
|
||
return SyncResult(
|
||
success=True,
|
||
externalId=externalId or batchNumber,
|
||
rawResponse={"status": resp.status, "body": body[:500]},
|
||
)
|
||
errMsg = f"HTTP {resp.status}: {body[:300]}"
|
||
logger.error("RMA pushBooking failed: status=%s, body=%s", resp.status, body[:500])
|
||
return SyncResult(success=False, errorMessage=errMsg)
|
||
except asyncio.TimeoutError:
|
||
logger.warning("RMA pushBooking timeout (30s)")
|
||
return SyncResult(
|
||
success=False,
|
||
errorMessage="Verbindung zum Buchhaltungssystem hat zu lange gedauert (Timeout). Bitte später erneut versuchen.",
|
||
)
|
||
except Exception as e:
|
||
logger.exception("RMA pushBooking error")
|
||
return SyncResult(success=False, errorMessage=str(e))
|
||
|
||
async def getBookingStatus(self, config: Dict[str, Any], externalId: str) -> SyncResult:
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
url = self._buildUrl(config, f"charts/{externalId}/transactions")
|
||
async with session.get(url, headers=self._buildHeaders(config), timeout=aiohttp.ClientTimeout(total=15)) as resp:
|
||
if resp.status == 200:
|
||
return SyncResult(success=True, externalId=externalId)
|
||
return SyncResult(success=False, errorMessage=f"HTTP {resp.status}")
|
||
except Exception as e:
|
||
return SyncResult(success=False, errorMessage=str(e))
|
||
|
||
async def getBookingByExternalId(self, config: Dict[str, Any], externalId: str) -> SyncResult:
|
||
"""Check if the GL batch/transaction still exists in RMA by external ID (id or batch_number)."""
|
||
if not externalId or not str(externalId).strip():
|
||
return SyncResult(success=False, errorMessage="Not found")
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
url = self._buildUrl(config, f"gl/{externalId.strip()}")
|
||
async with session.get(
|
||
url, headers=self._buildHeaders(config), timeout=aiohttp.ClientTimeout(total=15)
|
||
) as resp:
|
||
if resp.status == 200:
|
||
return SyncResult(success=True, externalId=externalId)
|
||
if resp.status == 404:
|
||
return SyncResult(success=False, errorMessage="Not found")
|
||
body = await resp.text()
|
||
return SyncResult(success=False, errorMessage=f"HTTP {resp.status}: {body[:200]}")
|
||
except Exception as e:
|
||
logger.debug("RMA getBookingByExternalId failed: %s", e)
|
||
return SyncResult(success=False, errorMessage=str(e))
|
||
|
||
async def isBookingSynced(self, config: Dict[str, Any], booking: AccountingBooking) -> SyncResult:
|
||
"""Check if booking exists in RMA by searching transactions for reference match.
|
||
Uses GET charts/{accno}/transactions with date filter. success=True = booking exists."""
|
||
if not booking.lines:
|
||
return SyncResult(success=True)
|
||
ref = (booking.reference or "").strip()[:32]
|
||
if not ref:
|
||
return SyncResult(success=True)
|
||
fromDate = (booking.bookingDate or "").split("T")[0].strip()[:10]
|
||
if not fromDate or len(fromDate) < 10:
|
||
return SyncResult(success=True)
|
||
accountNumbers = list({ln.accountNumber for ln in booking.lines if ln.accountNumber})
|
||
if not accountNumbers:
|
||
return SyncResult(success=True)
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
for accno in accountNumbers:
|
||
url = self._buildUrl(config, f"charts/{accno}/transactions")
|
||
params = {"from_date": fromDate, "to_date": fromDate}
|
||
async with session.get(
|
||
url, headers=self._buildHeaders(config), params=params, timeout=aiohttp.ClientTimeout(total=15)
|
||
) as resp:
|
||
if resp.status != 200:
|
||
continue
|
||
data = await resp.json()
|
||
transactions = data.get("transaction") if isinstance(data, dict) else []
|
||
if isinstance(data, list):
|
||
transactions = data
|
||
if not isinstance(transactions, list):
|
||
transactions = [transactions] if isinstance(transactions, dict) else []
|
||
for t in transactions:
|
||
if isinstance(t, dict) and (t.get("reference") or "").strip() == ref:
|
||
return SyncResult(success=True)
|
||
return SyncResult(success=False, errorMessage="Reference not found in RMA transactions")
|
||
except asyncio.TimeoutError:
|
||
logger.debug("RMA isBookingSynced timeout – trust local")
|
||
return SyncResult(success=True)
|
||
except Exception as e:
|
||
logger.debug("RMA isBookingSynced error: %s – trust local", e)
|
||
return SyncResult(success=True)
|
||
|
||
async def getJournalEntries(self, config: Dict[str, Any], dateFrom: Optional[str] = None, dateTo: Optional[str] = None, accountNumbers: Optional[List[str]] = None) -> List[Dict[str, Any]]:
|
||
"""Read GL entries from RMA.
|
||
|
||
Strategy: first try GET /gl (bulk), then fall back to iterating
|
||
account transactions. Uses pre-fetched accountNumbers if provided.
|
||
"""
|
||
try:
|
||
params: Dict[str, str] = {}
|
||
if dateFrom:
|
||
params["from_date"] = dateFrom
|
||
if dateTo:
|
||
params["to_date"] = dateTo
|
||
|
||
# Try bulk GL endpoint first
|
||
bulkEntries = await self._fetchGlBulk(config, params)
|
||
if bulkEntries:
|
||
return bulkEntries
|
||
|
||
# Fallback: iterate accounts and fetch transactions
|
||
if accountNumbers:
|
||
accNums = accountNumbers
|
||
else:
|
||
chart = await self.getChartOfAccounts(config)
|
||
accNums = [acc.accountNumber for acc in chart if acc.accountNumber]
|
||
if not accNums:
|
||
return []
|
||
|
||
entriesByRef: Dict[str, Dict[str, Any]] = {}
|
||
fetchedCount = 0
|
||
emptyCount = 0
|
||
errorCount = 0
|
||
async with aiohttp.ClientSession() as session:
|
||
for accNo in accNums:
|
||
url = self._buildUrl(config, f"charts/{accNo}/transactions")
|
||
try:
|
||
async with session.get(url, headers=self._buildHeaders(config), params=params, timeout=aiohttp.ClientTimeout(total=10)) as resp:
|
||
if resp.status != 200:
|
||
emptyCount += 1
|
||
continue
|
||
body = await resp.text()
|
||
if not body.strip():
|
||
emptyCount += 1
|
||
continue
|
||
try:
|
||
data = json.loads(body)
|
||
except Exception:
|
||
errorCount += 1
|
||
continue
|
||
except (asyncio.TimeoutError, Exception):
|
||
errorCount += 1
|
||
continue
|
||
fetchedCount += 1
|
||
|
||
if isinstance(data, dict):
|
||
transactions = data.get("transaction") or data.get("@transaction")
|
||
else:
|
||
transactions = data
|
||
if isinstance(transactions, dict):
|
||
transactions = [transactions]
|
||
if not isinstance(transactions, list):
|
||
continue
|
||
|
||
for t in transactions:
|
||
if not isinstance(t, dict):
|
||
continue
|
||
ref = t.get("reference") or t.get("@reference") or t.get("batch_number") or str(t.get("id") or "")
|
||
transDate = str(t.get("transdate") or t.get("@transdate") or "").split("T")[0]
|
||
desc = t.get("description") or t.get("memo") or t.get("@description") or ""
|
||
|
||
rawAmount = float(t.get("amount") or t.get("@amount") or 0)
|
||
debit = rawAmount if rawAmount > 0 else 0.0
|
||
credit = abs(rawAmount) if rawAmount < 0 else 0.0
|
||
|
||
if ref not in entriesByRef:
|
||
entriesByRef[ref] = {
|
||
"externalId": str(t.get("id") or t.get("@id") or ref),
|
||
"bookingDate": transDate,
|
||
"reference": ref,
|
||
"description": desc,
|
||
"currency": "CHF",
|
||
"totalAmount": 0.0,
|
||
"lines": [],
|
||
}
|
||
entry = entriesByRef[ref]
|
||
entry["lines"].append({
|
||
"accountNumber": accNo,
|
||
"debitAmount": debit,
|
||
"creditAmount": credit,
|
||
"description": desc,
|
||
})
|
||
entry["totalAmount"] += max(debit, credit)
|
||
|
||
return list(entriesByRef.values())
|
||
except Exception as e:
|
||
logger.error(f"RMA getJournalEntries error: {e}", exc_info=True)
|
||
return []
|
||
|
||
async def _fetchGlBulk(self, config: Dict[str, Any], params: Dict[str, str]) -> List[Dict[str, Any]]:
|
||
"""Try GET /gl to fetch journal entries in bulk (not all RMA versions support this)."""
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
url = self._buildUrl(config, "gl")
|
||
async with session.get(url, headers=self._buildHeaders(config), params=params, timeout=aiohttp.ClientTimeout(total=60)) as resp:
|
||
if resp.status != 200:
|
||
return []
|
||
body = await resp.text()
|
||
if not body.strip():
|
||
return []
|
||
try:
|
||
data = json.loads(body)
|
||
except Exception:
|
||
return []
|
||
|
||
items = data if isinstance(data, list) else (data.get("gl_batch") or data.get("gl") or data.get("items") or [])
|
||
if isinstance(items, dict):
|
||
items = [items]
|
||
if not isinstance(items, list):
|
||
return []
|
||
|
||
entries = []
|
||
for batch in items:
|
||
if not isinstance(batch, dict):
|
||
continue
|
||
transDate = str(batch.get("transdate") or batch.get("date") or "").split("T")[0]
|
||
ref = batch.get("batch_number") or batch.get("reference") or str(batch.get("id", ""))
|
||
desc = batch.get("description") or batch.get("notes") or ""
|
||
|
||
rawTxns = batch.get("gl_transactions", {})
|
||
txnList = rawTxns.get("gl_transaction") if isinstance(rawTxns, dict) else rawTxns
|
||
if isinstance(txnList, dict):
|
||
txnList = [txnList]
|
||
if not isinstance(txnList, list):
|
||
txnList = []
|
||
|
||
lines = []
|
||
totalAmt = 0.0
|
||
for t in txnList:
|
||
if not isinstance(t, dict):
|
||
continue
|
||
debit = float(t.get("debit_amount") or 0)
|
||
credit = float(t.get("credit_amount") or 0)
|
||
lines.append({
|
||
"accountNumber": str(t.get("accno", "")),
|
||
"debitAmount": debit,
|
||
"creditAmount": credit,
|
||
"description": t.get("memo", ""),
|
||
})
|
||
totalAmt += max(debit, credit)
|
||
|
||
entries.append({
|
||
"externalId": str(batch.get("id", ref)),
|
||
"bookingDate": transDate,
|
||
"reference": ref,
|
||
"description": desc,
|
||
"currency": batch.get("currency", "CHF"),
|
||
"totalAmount": totalAmt,
|
||
"lines": lines,
|
||
})
|
||
return entries
|
||
except Exception as e:
|
||
logger.debug(f"RMA _fetchGlBulk not available: {e}")
|
||
return []
|
||
|
||
async def pushInvoice(self, config: Dict[str, Any], invoice: Dict[str, Any]) -> SyncResult:
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
url = self._buildUrl(config, "invoices")
|
||
async with session.post(url, headers=self._buildHeaders(config), json=invoice, timeout=aiohttp.ClientTimeout(total=30)) as resp:
|
||
body = await resp.text()
|
||
if resp.status in (200, 201):
|
||
return SyncResult(success=True, rawResponse={"body": body[:500]})
|
||
return SyncResult(success=False, errorMessage=f"HTTP {resp.status}: {body[:300]}")
|
||
except Exception as e:
|
||
return SyncResult(success=False, errorMessage=str(e))
|
||
|
||
async def getCustomers(self, config: Dict[str, Any]) -> List[Dict[str, Any]]:
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
url = self._buildUrl(config, "customers")
|
||
async with session.get(url, headers=self._buildHeaders(config), timeout=aiohttp.ClientTimeout(total=30)) as resp:
|
||
if resp.status != 200:
|
||
return []
|
||
data = await self._parseJsonOrXmlList(resp, "customer")
|
||
return data
|
||
except Exception as e:
|
||
logger.error(f"RMA getCustomers error: {e}")
|
||
return []
|
||
|
||
async def getVendors(self, config: Dict[str, Any]) -> List[Dict[str, Any]]:
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
url = self._buildUrl(config, "vendors")
|
||
async with session.get(url, headers=self._buildHeaders(config), timeout=aiohttp.ClientTimeout(total=30)) as resp:
|
||
if resp.status != 200:
|
||
return []
|
||
data = await self._parseJsonOrXmlList(resp, "vendor")
|
||
return data
|
||
except Exception as e:
|
||
logger.error(f"RMA getVendors error: {e}")
|
||
return []
|
||
|
||
async def _parseJsonOrXmlList(self, resp: aiohttp.ClientResponse, itemKey: str) -> List[Dict[str, Any]]:
|
||
"""Parse RMA response that may be JSON or XML. Returns list of dicts."""
|
||
body = await resp.text()
|
||
if not body or not body.strip():
|
||
return []
|
||
try:
|
||
data = json.loads(body)
|
||
if isinstance(data, list):
|
||
return data
|
||
if isinstance(data, dict):
|
||
items = data.get(itemKey) or data.get("items") or data.get("row") or []
|
||
if isinstance(items, dict):
|
||
return [items]
|
||
return items if isinstance(items, list) else []
|
||
return []
|
||
except (json.JSONDecodeError, ValueError):
|
||
pass
|
||
result: List[Dict[str, Any]] = []
|
||
ids = re.findall(r"<id>([^<]+)</id>", body)
|
||
names = re.findall(r"<name>([^<]+)</name>", body)
|
||
for i, rid in enumerate(ids):
|
||
entry: Dict[str, Any] = {"id": rid.strip()}
|
||
if i < len(names):
|
||
entry["name"] = names[i].strip()
|
||
result.append(entry)
|
||
return result
|
||
|
||
async def _findBelegByFilename(self, config: Dict[str, Any], session: aiohttp.ClientSession, fileName: str) -> Optional[str]:
|
||
"""Try GET /belege (undocumented) to find an existing beleg by filename."""
|
||
try:
|
||
url = self._buildUrl(config, "belege")
|
||
async with session.get(url, headers=self._buildHeaders(config), timeout=aiohttp.ClientTimeout(total=15)) as resp:
|
||
body = await resp.text()
|
||
logger.info("RMA GET /belege: status=%s, body=%s", resp.status, body[:1000])
|
||
if resp.status != 200:
|
||
return None
|
||
try:
|
||
data = json.loads(body)
|
||
except Exception:
|
||
data = None
|
||
if isinstance(data, list):
|
||
items = data
|
||
elif isinstance(data, dict):
|
||
items = data.get("beleg_upload") or data.get("belege") or data.get("row") or []
|
||
if isinstance(items, dict):
|
||
items = [items]
|
||
else:
|
||
# Try XML: extract all <id> + <file_name> pairs
|
||
ids = re.findall(r"<id>([^<]+)</id>", body)
|
||
names = re.findall(r"<file_name>([^<]+)</file_name>", body)
|
||
for bid, fname in zip(ids, names):
|
||
if fileName.lower() in fname.lower():
|
||
logger.info("RMA GET /belege: matched filename=%s → belegId=%s", fname, bid)
|
||
return bid.strip()
|
||
return None
|
||
if not isinstance(items, list):
|
||
return None
|
||
for item in items:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
fname = item.get("file_name") or item.get("fileName") or ""
|
||
if fileName.lower() in fname.lower():
|
||
bid = item.get("id")
|
||
if bid:
|
||
logger.info("RMA GET /belege: matched filename=%s → belegId=%s", fname, bid)
|
||
return str(bid).strip()
|
||
except Exception as e:
|
||
logger.debug("RMA _findBelegByFilename failed: %s", e)
|
||
return None
|
||
|
||
def _parseExistingBelegId(self, body: str) -> Optional[str]:
|
||
"""Try to extract the existing Beleg-ID from a 409 duplicate response. Tries multiple patterns."""
|
||
if not (body or "").strip():
|
||
return None
|
||
# Pattern: "id":12345 or "id":"12345" in JSON
|
||
match = re.search(r'"id"\s*:\s*"?(\d+)"?', body)
|
||
if match:
|
||
return match.group(1).strip()
|
||
# Pattern: <id>12345</id> in XML
|
||
match = re.search(r"<id>([^<]+)</id>", body)
|
||
if match:
|
||
return match.group(1).strip()
|
||
# Pattern: numeric id in URL like /file/12345
|
||
match = re.search(r"/file/(\d+)", body)
|
||
if match:
|
||
return match.group(1).strip()
|
||
return None
|
||
|
||
def _parseBelegIdFromResponse(self, body: str) -> Optional[str]:
|
||
"""Extract Beleg-ID from RMA POST /belege response (XML or JSON)."""
|
||
if not (body or "").strip():
|
||
return None
|
||
try:
|
||
data = json.loads(body)
|
||
if isinstance(data, dict):
|
||
bid = data.get("id") or (data.get("beleg_upload") or {}).get("id")
|
||
if bid is not None:
|
||
return str(bid).strip()
|
||
except Exception:
|
||
pass
|
||
match = re.search(r"<id>([^<]+)</id>", body)
|
||
if match:
|
||
return match.group(1).strip()
|
||
return None
|
||
|
||
async def uploadDocument(
|
||
self,
|
||
config: Dict[str, Any],
|
||
fileName: str,
|
||
fileContent: bytes,
|
||
mimeType: str = "application/pdf",
|
||
comment: Optional[str] = None,
|
||
) -> SyncResult:
|
||
"""Upload a receipt via POST /belege (multipart/form-data). Returns SyncResult with externalId = Beleg-ID when present."""
|
||
try:
|
||
formData = aiohttp.FormData()
|
||
formData.add_field("Filedata", fileContent, filename=fileName, content_type=mimeType)
|
||
if comment:
|
||
formData.add_field("comment", comment[:500])
|
||
|
||
headers = self._buildHeaders(config)
|
||
headers.pop("Content-Type", None) # let aiohttp set multipart boundary
|
||
headers["Accept"] = "*/*" # RMA may return XML on error; avoid 406 Not Acceptable
|
||
async with aiohttp.ClientSession() as session:
|
||
url = self._buildUrl(config, "belege")
|
||
async with session.post(url, headers=headers, data=formData, timeout=aiohttp.ClientTimeout(total=60)) as resp:
|
||
body = await resp.text()
|
||
belegId = self._parseBelegIdFromResponse(body)
|
||
if resp.status in (200, 201):
|
||
return SyncResult(
|
||
success=True,
|
||
externalId=belegId,
|
||
rawResponse={"body": body[:500]},
|
||
)
|
||
if resp.status == 409:
|
||
logger.info("RMA uploadDocument 409 (duplicate), body=%s", body[:500])
|
||
if not belegId:
|
||
belegId = self._parseExistingBelegId(body)
|
||
if not belegId:
|
||
belegId = await self._findBelegByFilename(config, session, fileName)
|
||
return SyncResult(
|
||
success=True,
|
||
externalId=belegId,
|
||
rawResponse={"body": body[:500]},
|
||
)
|
||
errMsg = f"HTTP {resp.status}: {body[:300]}"
|
||
logger.error("RMA uploadDocument failed: status=%s, body=%s", resp.status, body[:500])
|
||
return SyncResult(success=False, errorMessage=errMsg)
|
||
except Exception as e:
|
||
logger.exception("RMA uploadDocument error")
|
||
return SyncResult(success=False, errorMessage=str(e))
|