Schnellstart

uv add ecmind-blue-client

pip install ecmind-blue-client

# Importskript: linearer Code, kein Event Loop
ecm = ECM(SyncPoolClient(servers="<host>:4000:1", username="<user>", password="<pass>"))

for folder in ecm.dms.select(InvoiceFolder).stream():
    print(folder.system.id, folder.Title)

# FastAPI-Endpunkt: in einem bestehenden Event Loop
ecm = ECM(AsyncPoolClient(servers="<host>:4000:1", username="<user>", password="<pass>"))

@app.get("/folders")
async def list_folders():
    return [
        {"id": folder.system.id, "title": folder.Title}
        async for folder in ecm.dms.select(InvoiceFolder).stream()
    ]

from ecmind_blue_client.ecm import ECM
from ecmind_blue_client.pool import SyncPoolClient

client = SyncPoolClient(
    servers="<host>:4000:1",
    username="<username>",
    password="<password>",
)
ecm = ECM(client)

from ecmind_blue_client.ecm import ECM
from ecmind_blue_client.pool import AsyncPoolClient

client = AsyncPoolClient(
    servers="<host>:4000:1",
    username="<username>",
    password="<password>",
)
ecm = ECM(client)

from models.Invoices import InvoiceFolder

for folder in (
    ecm.dms.select(InvoiceFolder)
    .where(InvoiceFolder.Year >= 2024)
    .order_by(InvoiceFolder.Year.DESC)
    .stream()
):
    print(folder.system.id, folder.Title, folder.Year)

from models.Invoices import InvoiceFolder

async for folder in (
    ecm.dms.select(InvoiceFolder)
    .where(InvoiceFolder.Year >= 2024)
    .order_by(InvoiceFolder.Year.DESC)
    .stream()
):
    print(folder.system.id, folder.Title, folder.Year)

folder = ecm.dms.get(InvoiceFolder, 4711)
print(folder.Title)

folder = await ecm.dms.get(InvoiceFolder, 4711)
print(folder.Title)

folder.Title = "Rechnung 2024 (korrigiert)"
print(folder.system.is_modified)       # True
print(folder.system.modified_fields)   # {'Title': 'Rechnung 2024 (korrigiert)'}

ecm.dms.update(folder)

folder.Title = "Rechnung 2024 (korrigiert)"
print(folder.system.is_modified)       # True
print(folder.system.modified_fields)   # {'Title': 'Rechnung 2024 (korrigiert)'}

await ecm.dms.update(folder)

result = ecm.db.select(
    "SELECT id, benutzer FROM benutzer WHERE benutzer = %s",
    "admin",
)
for row in result:
    print(row["benutzer"])

result = await ecm.db.select(
    "SELECT id, benutzer FROM benutzer WHERE benutzer = %s",
    "admin",
)
for row in result:
    print(row["benutzer"])

from ecmind_blue_client.rpc import JobRequestFileFromPath

object_id, type_id, hits, action = (
    ecm.dms.upsert(
        InvoiceDocument(Title="Rechnung 4711", InvoiceDate=date(2024, 3, 1)),
        folder_id=folder.system.id,
    )
    .search(InvoiceDocument.Title == "Rechnung 4711")
    .files([JobRequestFileFromPath("rechnung.pdf")], replace=True)
    .execute()
)

from ecmind_blue_client.rpc import JobRequestFileFromPath

object_id, type_id, hits, action = await (
    ecm.dms.upsert(
        InvoiceDocument(Title="Rechnung 4711", InvoiceDate=date(2024, 3, 1)),
        folder_id=folder.system.id,
    )
    .search(InvoiceDocument.Title == "Rechnung 4711")
    .files([JobRequestFileFromPath("rechnung.pdf")], replace=True)
    .execute()
)

for response_file in ecm.dms.files(document):
    print(response_file.name, response_file.size())
    response_file.store("/tmp/" + response_file.name)  # auf die Festplatte schreiben
    content = response_file.bytes()                    # oder die Bytes übernehmen

for response_file in await ecm.dms.files(document):
    print(response_file.name, response_file.size())
    response_file.store("/tmp/" + response_file.name)  # auf die Festplatte schreiben
    content = response_file.bytes()                    # oder die Bytes übernehmen

# Als Context-Manager
with ecm.impersonate("john") as ecm_john:
    folder = ecm_john.dms.insert_and_get(InvoiceFolder(Title="Test"))

# Oder direkt ohne with-Block
ecm_john = ecm.impersonate("john")
folder = ecm_john.dms.insert_and_get(InvoiceFolder(Title="Test"))

# Oder über GUID bzw. numerische ID des Benutzers
ecm_john = ecm.impersonate(user_guid="8A1D1F2E4C7B4A9E8F0D3C5B7A9E1D2F")
ecm_john = ecm.impersonate(user_id=42)

# Als Context-Manager
async with ecm.impersonate("john") as ecm_john:
    folder = await ecm_john.dms.insert_and_get(InvoiceFolder(Title="Test"))

# Oder direkt ohne with-Block
ecm_john = ecm.impersonate("john")
folder = await ecm_john.dms.insert_and_get(InvoiceFolder(Title="Test"))

import logging
import os
from datetime import date

from ecmind_blue_client import set_server_timezone
from ecmind_blue_client.ecm import ECM, ECMException
from ecmind_blue_client.pool import SyncPoolClient
from ecmind_blue_client.rpc import JobRequestFileFromPath

from models.Invoices import InvoiceDocument, InvoiceFolder, InvoiceRegister

logging.basicConfig(level=logging.INFO)
log = logging.getLogger("invoice-import")


def main() -> None:
    set_server_timezone("Europe/Zurich")

    client = SyncPoolClient(
        servers=os.environ["ECM_SERVERS"],
        username=os.environ["ECM_USERNAME"],
        password=os.environ["ECM_PASSWORD"],
    )
    ecm = ECM(client)

    try:
        # 1. SQL: eine Auswertungszahl, die die Objekt-API nicht ausdrücken kann
        result = ecm.db.select("SELECT COUNT(*) AS anzahl FROM benutzer WHERE aktiv = %d", 1)
        log.info("aktive Benutzer: %s", result.rows[0].typed("anzahl", int))

        # 2. Ordner: anlegen oder aktualisieren, falls er bereits existiert
        folder = (
            ecm.dms.upsert(InvoiceFolder(Title="Rechnung 2024", Year=2024))
            .search(InvoiceFolder.Title == "Rechnung 2024")
            .execute_and_get()
        )
        log.info("Ordner %s", folder.system.id)

        # 3. Register in diesem Ordner, Dokument samt Datei in diesem Register
        register = ecm.dms.insert_and_get(InvoiceRegister(Name="März"), folder_id=folder)
        document = ecm.dms.insert_and_get(
            InvoiceDocument(Title="Rechnung 4711", InvoiceDate=date(2024, 3, 1)),
            [JobRequestFileFromPath("rechnung.pdf")],
            folder_id=folder,
            register_id=register,
        )
        log.info("Dokument %s mit %s Datei(en)", document.system.id, len(ecm.dms.files(document)))

        # 4. Lesen: alle Ordner ab 2024, neueste zuerst
        for hit in (
            ecm.dms.select(InvoiceFolder)
            .where(InvoiceFolder.Year >= 2024)
            .order_by(InvoiceFolder.Year.DESC)
            .stream()
        ):
            log.info("%s %s %s", hit.system.id, hit.Title, hit.Year)

        # 5. Ein Feld ändern, nur dieses Feld geht an den Server
        document.Title = "Rechnung 4711 (geprüft)"
        ecm.dms.update(document)

        # 6. Im Namen von john ablegen, damit das Objekt ihn als Ersteller trägt
        #    (benötigt die Systemrolle Kontextwechsel)
        with ecm.impersonate("john") as ecm_john:
            filed = ecm_john.dms.insert_and_get(InvoiceFolder(Title="Rechnung 2024 (john)", Year=2024))
        log.info("abgelegt als john: %s", filed.system.id)

    except ECMException as error:
        log.error("der Server hat die Anfrage abgelehnt: %s", error)
    finally:
        client.close()


if __name__ == "__main__":
    main()

import asyncio
import logging
import os
from datetime import date

from ecmind_blue_client import set_server_timezone
from ecmind_blue_client.ecm import ECM, ECMException
from ecmind_blue_client.pool import AsyncPoolClient
from ecmind_blue_client.rpc import JobRequestFileFromPath

from models.Invoices import InvoiceDocument, InvoiceFolder, InvoiceRegister

logging.basicConfig(level=logging.INFO)
log = logging.getLogger("invoice-import")


async def main() -> None:
    set_server_timezone("Europe/Zurich")

    client = AsyncPoolClient(
        servers=os.environ["ECM_SERVERS"],
        username=os.environ["ECM_USERNAME"],
        password=os.environ["ECM_PASSWORD"],
    )
    ecm = ECM(client)

    try:
        # 1. SQL: eine Auswertungszahl, die die Objekt-API nicht ausdrücken kann
        result = await ecm.db.select("SELECT COUNT(*) AS anzahl FROM benutzer WHERE aktiv = %d", 1)
        log.info("aktive Benutzer: %s", result.rows[0].typed("anzahl", int))

        # 2. Ordner: anlegen oder aktualisieren, falls er bereits existiert
        folder = await (
            ecm.dms.upsert(InvoiceFolder(Title="Rechnung 2024", Year=2024))
            .search(InvoiceFolder.Title == "Rechnung 2024")
            .execute_and_get()
        )
        log.info("Ordner %s", folder.system.id)

        # 3. Register in diesem Ordner, Dokument samt Datei in diesem Register
        register = await ecm.dms.insert_and_get(InvoiceRegister(Name="März"), folder_id=folder)
        document = await ecm.dms.insert_and_get(
            InvoiceDocument(Title="Rechnung 4711", InvoiceDate=date(2024, 3, 1)),
            [JobRequestFileFromPath("rechnung.pdf")],
            folder_id=folder,
            register_id=register,
        )
        log.info("Dokument %s mit %s Datei(en)", document.system.id, len(await ecm.dms.files(document)))

        # 4. Lesen: alle Ordner ab 2024, neueste zuerst
        async for hit in (
            ecm.dms.select(InvoiceFolder)
            .where(InvoiceFolder.Year >= 2024)
            .order_by(InvoiceFolder.Year.DESC)
            .stream()
        ):
            log.info("%s %s %s", hit.system.id, hit.Title, hit.Year)

        # 5. Ein Feld ändern, nur dieses Feld geht an den Server
        document.Title = "Rechnung 4711 (geprüft)"
        await ecm.dms.update(document)

        # 6. Im Namen von john ablegen, damit das Objekt ihn als Ersteller trägt
        #    (benötigt die Systemrolle Kontextwechsel)
        async with ecm.impersonate("john") as ecm_john:
            filed = await ecm_john.dms.insert_and_get(
                InvoiceFolder(Title="Rechnung 2024 (john)", Year=2024)
            )
        log.info("abgelegt als john: %s", filed.system.id)

    except ECMException as error:
        log.error("der Server hat die Anfrage abgelehnt: %s", error)
    finally:
        await client.aclose()


if __name__ == "__main__":
    asyncio.run(main())