250 lines
9.7 KiB
Python
250 lines
9.7 KiB
Python
# Copyright (c) 2025 Patrick Motsch
|
|
# All rights reserved.
|
|
"""
|
|
Refresh accounting data from external system (e.g. Abacus) into local TrusteeData* tables.
|
|
Checks lastSyncAt to avoid redundant imports unless forceRefresh is set.
|
|
"""
|
|
|
|
import json
|
|
import logging
|
|
import time
|
|
from datetime import datetime as _dt, timezone as _tz
|
|
from typing import Dict, Any, Optional
|
|
|
|
from modules.datamodels.datamodelChat import ActionResult
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _isoToTs(isoDate: Optional[str]) -> Optional[float]:
|
|
"""``YYYY-MM-DD`` → UTC midnight unix timestamp (or None)."""
|
|
if not isoDate:
|
|
return None
|
|
try:
|
|
return _dt.strptime(isoDate.strip()[:10], "%Y-%m-%d").replace(tzinfo=_tz.utc).timestamp()
|
|
except (ValueError, AttributeError):
|
|
return None
|
|
|
|
|
|
def _tsToIso(ts) -> Optional[str]:
|
|
"""Unix timestamp → ``YYYY-MM-DD`` (or None)."""
|
|
if ts is None:
|
|
return None
|
|
try:
|
|
return _dt.fromtimestamp(float(ts), tz=_tz.utc).strftime("%Y-%m-%d")
|
|
except (ValueError, TypeError, OSError):
|
|
return None
|
|
|
|
_SYNC_THRESHOLD_SECONDS = 3600
|
|
|
|
|
|
async def refreshAccountingData(self, parameters: Dict[str, Any]) -> ActionResult:
|
|
"""Import/refresh accounting data from the configured external system.
|
|
|
|
If data was synced within the last hour and forceRefresh is not set,
|
|
returns cached counts without triggering an external sync.
|
|
"""
|
|
featureInstanceId = parameters.get("featureInstanceId") or (
|
|
self.services.featureInstanceId if hasattr(self.services, "featureInstanceId") else None
|
|
)
|
|
forceRefresh = parameters.get("forceRefresh", False)
|
|
if isinstance(forceRefresh, str):
|
|
forceRefresh = forceRefresh.lower() in ("true", "1", "yes")
|
|
dateFrom = parameters.get("dateFrom") or None
|
|
dateTo = parameters.get("dateTo") or None
|
|
|
|
if not featureInstanceId:
|
|
return ActionResult.isFailure(error="featureInstanceId is required")
|
|
|
|
try:
|
|
from modules.features.trustee.interfaceFeatureTrustee import getInterface as getTrusteeInterface
|
|
from modules.features.trustee.datamodelFeatureTrustee import (
|
|
TrusteeAccountingConfig,
|
|
TrusteeDataAccount,
|
|
TrusteeDataJournalEntry,
|
|
TrusteeDataJournalLine,
|
|
TrusteeDataContact,
|
|
TrusteeDataAccountBalance,
|
|
)
|
|
|
|
trusteeInterface = getTrusteeInterface(
|
|
self.services.user,
|
|
mandateId=self.services.mandateId,
|
|
featureInstanceId=featureInstanceId,
|
|
)
|
|
|
|
cfgRecords = trusteeInterface.db.getRecordset(
|
|
TrusteeAccountingConfig,
|
|
recordFilter={"featureInstanceId": featureInstanceId, "isActive": True},
|
|
)
|
|
if not cfgRecords:
|
|
return ActionResult.isFailure(error="No active accounting configuration found for this Trustee instance")
|
|
|
|
cfgRecord = cfgRecords[0]
|
|
lastSyncAt = cfgRecord.get("lastSyncAt") or 0
|
|
lastSyncStatus = cfgRecord.get("lastSyncStatus") or ""
|
|
|
|
isFresh = (
|
|
lastSyncAt
|
|
and (time.time() - lastSyncAt) < _SYNC_THRESHOLD_SECONDS
|
|
and lastSyncStatus in ("success", "partial")
|
|
)
|
|
|
|
if isFresh and not forceRefresh:
|
|
counts = _getCachedCounts(trusteeInterface, featureInstanceId)
|
|
counts["synced"] = False
|
|
counts["lastSyncAt"] = lastSyncAt
|
|
counts["lastSyncStatus"] = lastSyncStatus
|
|
counts["message"] = f"Data is fresh (synced {int(time.time() - lastSyncAt)}s ago). Use forceRefresh=true to re-import."
|
|
dataExport = _exportAccountingData(trusteeInterface, featureInstanceId, dateFrom, dateTo)
|
|
return ActionResult.isSuccess(data={
|
|
"summary": counts,
|
|
"accountingData": dataExport,
|
|
})
|
|
|
|
from modules.features.trustee.accounting.accountingDataSync import AccountingDataSync
|
|
|
|
sync = AccountingDataSync(trusteeInterface)
|
|
summary = await sync.importData(
|
|
featureInstanceId=featureInstanceId,
|
|
mandateId=self.services.mandateId,
|
|
dateFrom=dateFrom,
|
|
dateTo=dateTo,
|
|
)
|
|
summary["synced"] = True
|
|
summary.pop("startedAt", None)
|
|
summary.pop("finishedAt", None)
|
|
|
|
try:
|
|
from modules.serviceCenter.services.serviceAgent.coreTools._featureSubAgentTools import clearFeatureQueryCache
|
|
clearFeatureQueryCache(featureInstanceId)
|
|
logger.info("Cleared feature query cache for instance %s after accounting import", featureInstanceId)
|
|
except Exception as cacheErr:
|
|
logger.warning("Could not clear feature query cache: %s", cacheErr)
|
|
|
|
dataExport = _exportAccountingData(trusteeInterface, featureInstanceId, dateFrom, dateTo)
|
|
return ActionResult.isSuccess(data={
|
|
"summary": summary,
|
|
"accountingData": dataExport,
|
|
})
|
|
except Exception as e:
|
|
logger.exception("refreshAccountingData failed")
|
|
return ActionResult.isFailure(error=str(e))
|
|
|
|
|
|
def _exportAccountingData(trusteeInterface, featureInstanceId: str, dateFrom: str = None, dateTo: str = None) -> str:
|
|
"""Export accounting data (accounts, balances, journal entries+lines) as compact JSON for downstream AI nodes."""
|
|
from modules.features.trustee.datamodelFeatureTrustee import (
|
|
TrusteeDataAccount,
|
|
TrusteeDataJournalEntry,
|
|
TrusteeDataJournalLine,
|
|
TrusteeDataAccountBalance,
|
|
)
|
|
try:
|
|
baseFilter = {"featureInstanceId": featureInstanceId}
|
|
|
|
accounts = trusteeInterface.db.getRecordset(TrusteeDataAccount, recordFilter=baseFilter) or []
|
|
accountMap = {}
|
|
for a in accounts:
|
|
nr = a.get("accountNumber", "")
|
|
accountMap[nr] = {
|
|
"nr": nr,
|
|
"label": a.get("label", ""),
|
|
"type": a.get("accountType", ""),
|
|
"group": a.get("accountGroup", ""),
|
|
}
|
|
|
|
balances = trusteeInterface.db.getRecordset(TrusteeDataAccountBalance, recordFilter=baseFilter) or []
|
|
balanceList = []
|
|
for b in balances:
|
|
balanceList.append({
|
|
"account": b.get("accountNumber", ""),
|
|
"year": b.get("periodYear", 0),
|
|
"month": b.get("periodMonth", 0),
|
|
"opening": b.get("openingBalance", 0),
|
|
"debit": b.get("debitTotal", 0),
|
|
"credit": b.get("creditTotal", 0),
|
|
"closing": b.get("closingBalance", 0),
|
|
})
|
|
|
|
entries = trusteeInterface.db.getRecordset(TrusteeDataJournalEntry, recordFilter=baseFilter) or []
|
|
fromTs = _isoToTs(dateFrom)
|
|
toTs = _isoToTs(dateTo)
|
|
entryMap = {}
|
|
for e in entries:
|
|
eid = e.get("id", "")
|
|
bDate = e.get("bookingDate")
|
|
if fromTs is not None and bDate is not None and float(bDate) < fromTs:
|
|
continue
|
|
if toTs is not None and bDate is not None and float(bDate) > toTs + 86399:
|
|
continue
|
|
entryMap[eid] = {
|
|
"date": _tsToIso(bDate),
|
|
"ref": e.get("reference", ""),
|
|
"desc": e.get("description", ""),
|
|
"amount": e.get("totalAmount", 0),
|
|
}
|
|
|
|
lines = trusteeInterface.db.getRecordset(TrusteeDataJournalLine, recordFilter=baseFilter) or []
|
|
lineList = []
|
|
for ln in lines:
|
|
jeId = ln.get("journalEntryId", "")
|
|
if jeId not in entryMap:
|
|
continue
|
|
entry = entryMap[jeId]
|
|
lineList.append({
|
|
"date": entry["date"],
|
|
"ref": entry["ref"],
|
|
"account": ln.get("accountNumber", ""),
|
|
"accountLabel": accountMap.get(ln.get("accountNumber", ""), {}).get("label", ""),
|
|
"debit": ln.get("debitAmount", 0),
|
|
"credit": ln.get("creditAmount", 0),
|
|
"desc": ln.get("description", "") or entry["desc"],
|
|
"taxCode": ln.get("taxCode", ""),
|
|
"costCenter": ln.get("costCenter", ""),
|
|
})
|
|
|
|
export = {
|
|
"accounts": list(accountMap.values()),
|
|
"balances": balanceList,
|
|
"journalLines": lineList,
|
|
"meta": {
|
|
"accountCount": len(accountMap),
|
|
"entryCount": len(entryMap),
|
|
"lineCount": len(lineList),
|
|
"balanceCount": len(balanceList),
|
|
"dateFrom": dateFrom,
|
|
"dateTo": dateTo,
|
|
},
|
|
}
|
|
result = json.dumps(export, ensure_ascii=False, default=str)
|
|
logger.info("Exported accounting data: %d accounts, %d entries, %d lines, %d balances (%d bytes)",
|
|
len(accountMap), len(entryMap), len(lineList), len(balanceList), len(result))
|
|
return result
|
|
except Exception as e:
|
|
logger.warning("Could not export accounting data: %s", e)
|
|
return ""
|
|
|
|
|
|
def _getCachedCounts(trusteeInterface, featureInstanceId: str) -> Dict[str, Any]:
|
|
"""Count existing records per TrusteeData* table without triggering an external sync."""
|
|
from modules.features.trustee.datamodelFeatureTrustee import (
|
|
TrusteeDataAccount,
|
|
TrusteeDataJournalEntry,
|
|
TrusteeDataJournalLine,
|
|
TrusteeDataContact,
|
|
TrusteeDataAccountBalance,
|
|
)
|
|
counts = {}
|
|
for label, model in [
|
|
("accounts", TrusteeDataAccount),
|
|
("journalEntries", TrusteeDataJournalEntry),
|
|
("journalLines", TrusteeDataJournalLine),
|
|
("contacts", TrusteeDataContact),
|
|
("accountBalances", TrusteeDataAccountBalance),
|
|
]:
|
|
records = trusteeInterface.db.getRecordset(
|
|
model, recordFilter={"featureInstanceId": featureInstanceId}
|
|
)
|
|
counts[label] = len(records) if records else 0
|
|
return counts
|