PyAPplus64 package

Submodules

PyAPplus64.applus module

class PyAPplus64.applus.APplusServer(db_settings: PyAPplus64.applus_db.APplusDBSettings, server_settings: PyAPplus64.applus_server.APplusServerSettings)

Bases: object

Verbindung zu einem APplus DB und App Server mit Hilfsfunktionen für den komfortablen Zugriff.

Parameter

  • db_settings (APplusDBSettings) – die Einstellungen für die Verbindung mit der Datenbank

  • server_settings (APplusAppServerSettings) – die Einstellungen für die Verbindung mit dem APplus App Server

  • web_settings (APplusWebServerSettings) – die Einstellungen für die Verbindung mit dem APplus Web Server

property client_adaptdb: zeep.client.Client
property client_nummer: zeep.client.Client
property client_table: zeep.client.Client
property client_xml: zeep.client.Client
completeSQL(sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], raw: bool = False) → str

Vervollständigt das SQL-Statement. Es wird z.B. der Mandant hinzugefügt.

Parameter

  • sql (sql_utils.SqlStatement) – das SQL Statement

  • raw (boolean) – soll completeSQL ausgeführt werden? Falls True, wird die Eingabe zurückgeliefert

Rückgabe

das vervollständigte SQL-Statement

Rückgabetyp

str

dbExecute(sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], *args: Any, raw: bool = False) → Any

Führt ein SQL Statement (z.B. update oder insert) aus. Das SQL wird zunächst vom Server angepasst, so dass z.B. Mandanteninformation hinzugefügt werden.

dbQuery(sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], f: Callable[[pyodbc.Row], None], *args: Any, raw: bool = False) → None

Führt eine SQL Query aus und führt für jede Zeile die übergeben Funktion aus. Das SQL wird zunächst vom Server angepasst, so dass z.B. Mandanteninformation hinzugefügt werden.

dbQueryAll(sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], *args: Any, raw: bool = False, apply: Optional[Callable[[pyodbc.Row], Any]] = None) → Any

Führt eine SQL Query aus und liefert alle Zeilen zurück. Das SQL wird zunächst vom Server angepasst, so dass z.B. Mandanteninformation hinzugefügt werden.

dbQuerySingleRow(sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], *args: Any, raw: bool = False) → Optional[pyodbc.Row]

Führt eine SQL Query aus, die maximal eine Zeile zurückliefern soll. Diese Zeile wird geliefert.

dbQuerySingleRowDict(sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], *args: Any, raw: bool = False) → Optional[Dict[str, Any]]

Führt eine SQL Query aus, die maximal eine Zeile zurückliefern soll. Diese Zeile wird als Dictionary geliefert.

dbQuerySingleValue(sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], *args: Any, raw: bool = False) → Any

Führt eine SQL Query aus, die maximal einen Wert zurückliefern soll. Dieser Wert oder None wird geliefert.

dbQuerySingleValues(sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], *args: Any, raw: bool = False) → Sequence[Any]

Führt eine SQL Query aus, die nur eine Spalte zurückliefern soll.

db_settings: PyAPplus64.applus_db.APplusDBSettings

Die Einstellungen für die Datenbankverbindung

execUseXMLRowDelete(table: str, id: int) → None
getAppClient(package: str, name: str) → zeep.client.Client

Erzeugt einen zeep - Client für den APP-Server. Mittels dieses Clients kann eines WSDL Schnittstelle des APP-Servers angesprochen werden. Wird als package „p2core“ und als name „Table“ verwendet und der resultierende client „client“ genannt, dann kann z.B. mittels „client.service.getCompleteSQL(sql)“ vom AppServer ein Vervollständigen des SQLs angefordert werden.

Parameter

  • package (string) – das Packet, z.B. „p2core“

  • name – der Name im Packet, z.B. „Table“

Rückgabe

den Client

Rückgabetyp

Client

getDBConnection() → pyodbc.Connection

Liefert eine pyodbc-Connection zur APplus DB. Diese muss genutzt werden, wenn mehrere Operationen in einer Transaktion genutzt werden sollen. Ansonsten sind die Hilfsmethoden wie APplusServer.dbQuery() zu bevorzugen. Diese Connection kann in Verbindung mit den Funktionen aus PyAPplus64.applus_db genutzt werden. Die Verbindung sollte nach Benutzung wieder freigegeben oder geschlossen werden.

getTableFields(table: str, isComputed: Optional[bool] = None) → Set[str]

Liefert die Namen aller Felder einer Tabelle.

Parameter

  • table – Name der Tabelle

  • isComputed – wenn gesetzt, werden nur die Felder geliefert, die berechnet werden oder nicht berechnet werden

Rückgabe

Liste aller Feld-Namen

Rückgabetyp

{str}

getUniqueFieldsOfTable(table: str) → Dict[str, List[str]]

Liefert alle Spalten einer Tabelle, die eindeutig sein müssen. Diese werden als Dictionary gruppiert nach Index-Namen geliefert. Jeder Eintrag enthält eine Liste von Feldern, die zusammen eindeutig sein müssen.

getWebClient(url: str) → zeep.client.Client

Erzeugt einen zeep - Client für den Web-Server. Mittels dieses Clients kann die von einer ASMX-Seite zur Verfügung gestellte Schnittstelle angesprochen werden. Als parameter wird die relative URL der ASMX-Seite erwartet. Die Base-URL automatisch ergänzt. Ein Beispiel für eine solche relative URL ist „masterdata/artikel.asmx“.

ACHTUNG: Als Umgebung wird die Umgebung des sich anmeldenden Nutzers verwendet. Sowohl Nutzer als auch Umgebung können sich von den für App-Clients verwendeten Werten unterscheiden. Wenn möglich, sollte ein App-Client verwendet werden.

Parameter

url – die relative URL der ASMX Seite, z.B. „masterdata/artikel.asmx“

Rückgabe

den Client

Rückgabetyp

Client

importUdfsAndViews()

Importiert bestimmte Views und UDFs :param environment: die Umgebung, in die Importiert werden soll :type environment: string :param views: Views, die importiert werden sollen :type views: [string] :param udfs: Views, die importiert werden sollen :type udfs: [string] :return: Infos zur Ausführung :rtype: str

isDBTableKnown(table: str) → bool

Prüft, ob eine Tabelle im System bekannt ist

job: PyAPplus64.applus_job.APplusJob

erlaubt Arbeiten mit Jobs

makeWebLinkAuftrag(**kwargs: Any) → str
makeWebLinkBauftrag(**kwargs: Any) → str
makeWebLinkVKRahmen(**kwargs: Any) → str
makeWebLinkWarenaugang(**kwargs: Any) → str
makeWebLinkWauftrag(**kwargs: Any) → str
makeWebLinkWauftragPos(**kwargs: Any) → str
mkUseXMLRowDelete(table: str, id: int) → PyAPplus64.applus_usexml.UseXmlRowDelete
mkUseXMLRowInsert(table: str) → PyAPplus64.applus_usexml.UseXmlRowInsert

Erzeugt ein Objekt zum Einfügen eines neuen DB-Eintrags.

Parameter

table (str) – DB-Tabelle in die eingefügt werden soll

Rückgabe

das XmlRow-Objekt

Rückgabetyp

applus_usexml.UseXmlRowInsert

mkUseXMLRowInsertOrUpdate(table: str) → PyAPplus64.applus_usexml.UseXmlRowInsertOrUpdate

Erzeugt ein Objekt zum Einfügen oder Updaten eines DB-Eintrags.

Parameter

table (string) – DB-Tabelle in die eingefügt werden soll

Rückgabe

das XmlRow-Objekt

Rückgabetyp

applus_usexml.UseXmlRowInsertOrUpdate

mkUseXMLRowUpdate(table: str, id: int) → PyAPplus64.applus_usexml.UseXmlRowUpdate
nextNumber(obj: str) → str

Erstellt eine neue Nummer für das Objekt und legt diese Nummer zurück.

reconnectDB() → None
releaseDBConnection(conn: pyodbc.Connection) → None

Gibt eine DB-Connection zur Wiederverwendung frei

scripttool: PyAPplus64.applus_scripttool.APplusScriptTool

erlaubt den einfachen Zugriff auf Funktionen des ScriptTools

server_conn: PyAPplus64.applus_server.APplusServerConnection

erlaubt den Zugriff auf den AppServer

server_settings: PyAPplus64.applus_server.APplusServerSettings

Einstellung für die Verbindung zum APP- und Webserver

sysconf: PyAPplus64.applus_sysconf.APplusSysConf

erlaubt den Zugriff auf die Sysconfig

updateDatabase(file: str) → str

Führt eine DBAnpass-xml Datei aus. :param file: DB-Anpass Datei, die ausgeführt werden soll :type file: string :return: Infos zur Ausführung :rtype: str

useXML(xml: str) → Any

Ruft p2core.xml.usexml auf. Wird meist durch ein UseXMLRow-Objekt aufgerufen.

class PyAPplus64.applus.APplusServerConfigDescription(descr: str, yamlfile: FileDescriptorOrPath, user: Optional[str] = None, env: Optional[str] = None)

Bases: object

Beschreibung einer Configuration bestehend aus Config-Datei, Nutzer und Umgebung.

Parameter

  • descr (str) – Beschreibung als String, nur für Ausgabe gedacht

  • yamlfile ('FileDescriptorOrPath') – die Datei

  • user (Optional[str]) – der Nutzer

  • env (Optional[str]) – die Umgebung

connect() → PyAPplus64.applus.APplusServer
PyAPplus64.applus.applusFromConfig(yamlString: str, user: Optional[str] = None, env: Optional[str] = None) → PyAPplus64.applus.APplusServer

Läd Einstellungen aus einer Config-Datei und erzeugt daraus ein APplus-Objekt

PyAPplus64.applus.applusFromConfigDict(yamlDict: Dict[str, Any], user: Optional[str] = None, env: Optional[str] = None) → PyAPplus64.applus.APplusServer

Läd Einstellungen aus einer Config und erzeugt daraus ein APplus-Objekt

PyAPplus64.applus.applusFromConfigFile(yamlfile: FileDescriptorOrPath, user: Optional[str] = None, env: Optional[str] = None) → PyAPplus64.applus.APplusServer

Läd Einstellungen aus einer Config-Datei und erzeugt daraus ein APplus-Objekt

PyAPplus64.applus_db module

class PyAPplus64.applus_db.APplusDBSettings(server: str, database: str, user: str, password: str)

Bases: object

Einstellungen, mit welcher DB sich verbunden werden soll.

connect() → pyodbc.Connection

Stellt eine neue Verbindung her und liefert diese zurück.

getConnectionString() → str

Liefert den ODBC Connection-String für die Verbindung. :return: den Connection-String

class PyAPplus64.applus_db.DBTableIDs

Bases: object

Klasse, die Mengen von IDs gruppiert nach Tabellen speichert

add(table: str, *ids: int) → None

fügt Eintrag hinzu

Parameter

  • table (str) – die Tabelle

  • id – die ID

getTable(table: str) → Set[int]

Liefert die Menge der IDs für eine bestimmte Tabelle.

Parameter

table (str) – die Tabelle

Rückgabe

die IDs

PyAPplus64.applus_db.getUniqueFieldsOfTable(cnxn: pyodbc.Connection, table: str) → Dict[str, List[str]]

Liefert alle Spalten einer Tabelle, die eindeutig sein müssen. Diese werden als Dictionary gruppiert nach Index-Namen geliefert. Jeder Eintrag enthält eine Liste von Feldern, die zusammen eindeutig sein müssen.

PyAPplus64.applus_db.rawExecute(cnxn: pyodbc.Connection, sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], *args: Any) → Any

Führt ein SQL Statement direkt aus

PyAPplus64.applus_db.rawQuery(cnxn: pyodbc.Connection, sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], f: Callable[[pyodbc.Row], None], *args: Any) → None

Führt eine SQL Query direkt aus und führt für jede Zeile die übergeben Funktion aus.

PyAPplus64.applus_db.rawQueryAll(cnxn: pyodbc.Connection, sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], *args: Any, apply: Optional[Callable[[pyodbc.Row], Any]] = None) → Sequence[Any]

Führt eine SQL Query direkt aus und liefert alle Zeilen zurück. Wenn apply gesetzt ist, wird die Funktion auf jeder Zeile ausgeführt und das Ergebnis ausgeben, die nicht None sind.

PyAPplus64.applus_db.rawQuerySingleRow(cnxn: pyodbc.Connection, sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], *args: Any) → Optional[pyodbc.Row]

Führt eine SQL Query direkt aus, die maximal eine Zeile zurückliefern soll. Diese Zeile wird geliefert.

PyAPplus64.applus_db.rawQuerySingleValue(cnxn: pyodbc.Connection, sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], *args: Any) → Any

Führt eine SQL Query direkt aus, die maximal einen Wert zurückliefern soll. Dieser Wert oder None wird geliefert.

PyAPplus64.applus_db.row_to_dict(row: pyodbc.Row) → Dict[str, Any]

Konvertiert eine Zeile in ein Dictionary

PyAPplus64.applus_job module

class PyAPplus64.applus_job.APplusJob(server: APplusServer)

Bases: object

Zugriff auf Jobs

Parameter

server (APplusServer) – die Verbindung zum Server

property client: zeep.client.Client
createSOAPJob(bez: str) → str

Erzeugt einen neuen SOAP Job mit der gegebenen Bezeichnung und liefert die neue JobID. :param bez: die Bezeichnung des neuen Jobs :type bez: str :return: die neue JobID :rtype: str

finish(jobId: str, status: int, resurl: str) → bool

Beendet den Job :param jobId: die ID des Jobs :type jobId: str :param status: der Status 2 (OK), 3 (Fehler) :type status: int :param resurl: die neue resurl des Jobs :type resurl: str

getInfo(jobId: str) → str

Liefert die Info eines Jobs :param jobId: die ID des Jobs :type jobId: str :return: die Info :rtype: str

getPtURL(jobId: str) → str

Liefert die PtURL eines Jobs :param jobId: die ID des Jobs :type jobId: str :return: die Pt-URL :rtype: str

getResult(jobId: str) → str

Liefert das Result eines Jobs :param jobId: die ID des Jobs :type jobId: str :return: das Result :rtype: str

getResultURL(jobId: str) → str

Liefert die ResultURL eines Jobs :param jobId: die ID des Jobs :type jobId: str :return: die Result-URL :rtype: str

getResultURLString(jobId: str) → Optional[str]

Liefert die ResultURL eines Jobs, wobei ein evtl. Präfix „retstring://“ entfernt wird und alle anderen Werte durch None ersetzt werden. :param jobId: die ID des Jobs :type jobId: str :return: die Result-URL als String :rtype: str

getStatus(jobId: str) → str

Liefert Informationen zum Job :param jobId: die ID des Jobs :type jobId: str :return: die Infos :rtype: str

kill(jobId: str) → None

Startet einen Job :param jobId: die ID des Jobs :type jobId: str

restart(jobId: str) → str

Startet einen Job neu :param jobId: die ID des Jobs :type jobId: str :return: die URL des Jobs :rtype: str

setInfo(jobId: str, info: str) → bool

Setzt die Informationen zu dem Job :param jobId: die ID des Jobs :type jobId: str :param info: die neuen Infos :type info: str

setPosition(jobId: str, pos: int, max: int) → bool

Schrittfunktion :param jobId: die ID des Jobs :type jobId: str :param pos: Position :type pos: int :param max: Anzahl Schritte in Anzeige :type max: int

setPtURL(jobId: str, pturl: str) → None

Setzt die ResultURL eines Jobs :param jobId: die ID des Jobs :type jobId: str :param pturl: die neue PtURL :type pturl: str

setResult(jobId: str, res: str) → None

Setzt das Result eines Jobs :param jobId: die ID des Jobs :type jobId: str :param res: das neue Result :type res: str

setResultURL(jobId: str, resurl: str) → None

Setzt die ResultURL eines Jobs :param jobId: die ID des Jobs :type jobId: str :param resurl: die neue Result-URL :type resurl: str

start(jobId: str) → bool

Startet einen Job :param jobId: die ID des Jobs :type jobId: str

PyAPplus64.applus_scripttool module

class PyAPplus64.applus_scripttool.APplusScriptTool(server: PyAPplus64.applus.APplusServer)

Bases: object

Zugriff auf AppServer ScriptTool

Parameter

server (APplusServerConnection) – die Verbindung zum Server

property client: zeep.client.Client
getAllEnvironments()

Liefert alle Umgebungen

Rückgabe

die gefundenen Umgebungen

Rückgabetyp

[str]

getCurrentDate() → str
getCurrentDateTime() → str
getCurrentTime() → str
getInstallPath() → str

Liefert den Installionspfad des Appservers

getInstallPathAppServer() → pathlib.Path

Liefert den Installionspfad des Appservers als PathLib-Path

getInstallPathWebServer() → pathlib.Path

Liefert den Installionspfad des Webservers als PathLib-Path

getLoginName() → str
getMandant() → str

Liefert den aktuellen Mandanten

getMandantName() → str

Liefert den Namen des aktuellen Mandanten

getServerInfo() → Optional[lxml.etree.Element]

Liefert Informationen zum Server als ein XML Dokument.

Rückgabe

das gefundene und geparste XML-Dokument

Rückgabetyp

ET.Element

getServerInfoString() → str

Liefert Informationen zum Server als String. Dieser String repräsentiert ein XML Dokument.

Rückgabe

das XML-Dokument als String

Rückgabetyp

str

getSystemName() → str
getUserFullName() → str
getUserName() → str
getXMLDefinition(obj: str, mandant: str = '', checkFileExists: bool = False) → Optional[lxml.etree.Element]

Läd die XML-Definition als String vom APPServer. und parst das XML in ein minidom-Dokument.

Parameter

  • obj (str) – das Objekt, dessen Definition zu laden ist, „Artikel“ läd z.B. „ArtikelDefinition.xml“

  • mandant (str optional) – der Mandant, dessen XML-Doku geladen werden soll, wenn „“ wird der Standard-Mandant verwendet

Rückgabe

das gefundene und geparste XML-Dokument

Rückgabetyp

ET.Element

getXMLDefinitionObj(obj: str, mandant: str = '') → Optional[PyAPplus64.applus_scripttool.XMLDefinition]

Benutzt getXMLDefinitionObj und liefert den Top-Level „Object“ Knoten zurück, falls zusätzlich ein MD5 Knoten existiert, also falls das Dokument wirklich vom Dateisystem geladen werden konnte. Ansonten wird None geliefert.

Parameter

  • obj (str) – das Objekt, dess Definition zu laden ist, „Artikel“ läd z.B. „ArtikelDefinition.xml“

  • mandant (str optional) – der Mandant, dessen XML-Doku geladen werden soll, wenn „“ wird der Standard-Mandant verwendet

Rückgabe

das gefundene und geparste XML-Dokument

Rückgabetyp

Optional[XMLDefinition]

getXMLDefinitionString(obj: str, mandant: str = '') → str

Läd die XML-Defintion als String vom APPServer. Auch wenn kein XML-Dokument im Dateisystem gefunden wird, wird ein String zurückgeliefert, der einen leeren Top-„Object“ Knoten enthält. Für gefundene XML-Dokumente gibt es zusätzlich einen Top-„MD5“-Knoten.

Parameter

  • obj (str) – das Objekt, dessen Definition zu laden ist, „Artikel“ läd z.B. „ArtikelDefinition.xml“

  • mandant (str optional) – der Mandant, dessen XML-Doku geladen werden soll, wenn „“ wird der Standard-Mandant verwendet

Rückgabe

das gefundene XML-Dokument als String

Rückgabetyp

str

class PyAPplus64.applus_scripttool.XMLDefinition(root: lxml.etree.Element)

Bases: object

Repräsentation eines XML-Dokuments

getDuplicate() → Tuple[Set[str], bool]

Extrahiert alle Properties, die für Duplizieren konfiguriert sind. Zudem wird ein Flag geliefert, ob diese Properties ein oder ausgeschlossen werden sollen. :return: Tuple aus allen Properties und ob dies aus- (True) oder ein-(False) zuschließen sind. :rtype: Tuple[Set[str], bool]

root: lxml.etree.Element

das Root-Element, repräsentiert „object“ aus Datei.

PyAPplus64.applus_server module

class PyAPplus64.applus_server.APplusServerConnection(settings: PyAPplus64.applus_server.APplusServerSettings)

Bases: object

Verbindung zu einem APplus APP- und Web-Server

Parameter

settings (APplusAppServerSettings) – die Einstellungen für die Verbindung mit dem APplus Server

getAppClient(package: str, name: str) → zeep.client.Client

Erzeugt einen zeep - Client für den APP-Server. Mittels dieses Clients kann die WSDL Schnittstelle angesprochen werden. Wird als package „p2core“ und als name „Table“ verwendet und der resultierende client „client“ genannt, dann kann z.B. mittels „client.service.getCompleteSQL(sql)“ vom AppServer ein Vervollständigen des SQLs angefordert werden.

Parameter

  • package (string) – das Packet, z.B. „p2core“

  • name – der Name im Packet, z.B. „Table“

Rückgabe

den Client

Rückgabetyp

Client

getWebClient(url: str) → zeep.client.Client

Erzeugt einen zeep - Client für den Web-Server. Mittels dieses Clients kann die von einer ASMX-Seite zur Verfügung gestellte Schnittstelle angesprochen werden. Als parameter wird die relative URL der ASMX-Seite erwartet. Die Base-URL automatisch ergänzt. Ein Beispiel für eine solche relative URL ist „masterdata/artikel.asmx“.

ACHTUNG: Als Umgebung wird die Umgebung des sich anmeldenden Nutzers verwendet. Sowohl Nutzer als auch Umgebung können sich von den für App-Clients verwendeten Werten unterscheiden. Wenn möglich, sollte ein App-Client verwendet werden.

Parameter

url – die relative URL der ASMX Seite, z.B. „masterdata/artikel.asmx“

Rückgabe

den Client

Rückgabetyp

Client

class PyAPplus64.applus_server.APplusServerSettings(webserver: str, appserver: str, appserverPort: int, user: str, env: Optional[str] = None, webserverUser: Optional[str] = None, webserverUserDomain: Optional[str] = None, webserverPassword: Optional[str] = None)

Bases: object

Einstellungen, mit welchem APplus App- and Web-Server sich verbunden werden soll.

PyAPplus64.applus_sysconf module

class PyAPplus64.applus_sysconf.APplusSysConf(server: APplusServer)

Bases: object

SysConf Zugriff mit Cache über AppServer

Parameter

server (APplusServer) – die Verbindung zum Server

clearCache() → None
property client: zeep.client.Client
getBoolean(module: str, name: str, useCache: bool = True) → bool
getDouble(module: str, name: str, useCache: bool = True) → float
getInt(module: str, name: str, useCache: bool = True) → int
getList(module: str, name: str, useCache: bool = True, sep: str = ',') → Optional[Sequence[str]]
getString(module: str, name: str, useCache: bool = True) → str

PyAPplus64.applus_usexml module

class PyAPplus64.applus_usexml.UseXmlRow(applus: APplusServer, table: str, cmd: str)

Bases: object

Klasse, die eine XML-Datei erzeugen kann, die mittels p2core.useXML genutzt werden kann. Damit ist es möglich APplus BusinessObjekte zu erzeugen, ändern und zu löschen. Im Gegensatz zu direkten DB-Zugriffen, werden diese Anfragen über den APP-Server ausgeführt. Dabei werden die von der Weboberfläche bekannten Checks und Änderungen ausgeführt. Als sehr einfaches Beispiel wird z.B. INSDATE oder UPDDATE automatisch gesetzt. Interessanter sind automatische Änderungen und Checks.

Bei der Benutzung wird zunächst ein Objekt erzeugt, dann evtl. mittels addField() Felder hinzugefügt und schließlich mittels exec() an den AppServer übergeben. Normalerweise sollte die Klasse nicht direkt, sondern über Unterklassen für das Einfügen, Ändern oder Löschen benutzt werden.

Parameter

  • applus (APplusServer) – Verbindung zu APplus

  • table (str) – die Tabelle

  • cmd (str) – cmd-attribut der row, also ob es sich um ein Update, ein Insert oder ein Delete handelt

addField(name: Optional[str], value: Any) → None

Fügt ein Feld zum Row-Node hinzu.

Parameter

  • name (string) – das Feld

  • value – Wert des Feldes

addTimestampField(id: int, ts: Optional[bytes] = None) → None

Fügt ein Timestamp-Feld hinzu. Wird kein Timestamp übergeben, wird mittels der ID der aktuelle Timestamp aus der DB geladen. Dabei kann ein Fehler auftreten. Ein Timestamp-Feld ist für Updates und das Löschen nötig um sicherzustellen, dass die richtige Version des Objekts geändert oder gelöscht wird. Wird z.B. ein Objekt aus der DB geladen, inspiziert und sollen dann Änderungen gespeichert werden, so sollte der Timestamp des Ladens übergeben werden. So wird sichergestellt, dass nicht ein anderer User zwischenzeitlich Änderungen vornahm. Ist dies der Fall, wird dann bei „exec“ eine Exception geworfen.

Parameter

  • id (string) – DB-id des Objektes dessen Timestamp hinzugefügt werden soll

  • ts (bytes) – Fester Timestamp der verwendet werden soll, wenn None wird der Timestamp aus der DB geladen.

addTimestampIDFields(id: int, ts: Optional[bytes] = None) → None

Fügt ein Timestamp-Feld sowie ein Feld id hinzu. Wird kein Timestamp übergeben, wird mittels der ID der aktuelle Timestamp aus der DB geladen. Dabei kann ein Fehler auftreten. Intern wird addTimestampField() benutzt.

Parameter

  • id (string) – DB-id des Objektes dessen Timestamp hinzugefügt werden soll

  • ts (bytes) – Fester Timestamp der verwendet werden soll, wenn None wird der Timestamp aus der DB geladen.

checkFieldSet(name: Optional[str]) → bool

Prüft, ob ein Feld gesetzt wurde

checkFieldsSet(*names: str) → bool

Prüft, ob alle übergebenen Felder gesetzt sind

exec() → Any

Führt die UseXmlRow mittels useXML aus. Je nach Art der Zeile wird etwas zurückgeliefert oder nicht. In jedem Fall kann eine Exception geworfen werden.

getField(name: str) → Any

Liefert den Wert eines gesetzten Feldes

toprettyxml() → str

Gibt das formatierte XML aus. Dieses kann per useXML an den AppServer übergeben werden. Dies wird mittels exec() automatisiert.

class PyAPplus64.applus_usexml.UseXmlRowDelete(applus: APplusServer, table: str, id: int, ts: Optional[bytes] = None)

Bases: PyAPplus64.applus_usexml.UseXmlRow

Klasse, die eine XML-Datei für das Löschen eines neuen Datensatzes erzeugen kann. Die Felder id und timestamp werden automatisch gesetzt. Dies sind die einzigen Felder, die gesetzt werden sollten.

Parameter

  • applus (APplusServer) – Verbindung zu APplus

  • table (string) – die Tabelle

  • id (int) – die zu löschende ID

  • ts (bytes optional) – wenn gesetzt, wird dieser Timestamp verwendet, sonst der aktuelle aus der DB

delete() → None

Führt das delete aus. Evtl. wird dabei eine Exception geworfen. Dies ist eine Umbenennung von exec().

class PyAPplus64.applus_usexml.UseXmlRowInsert(applus: APplusServer, table: str)

Bases: PyAPplus64.applus_usexml.UseXmlRow

Klasse, die eine XML-Datei für das Einfügen eines neuen Datensatzes erzeugen kann.

Parameter

  • applus (APplusServer) – Verbindung zu APplus

  • table (string) – die Tabelle

insert() → int

Führt das insert aus. Entweder wird dabei eine Exception geworfen oder die ID des neuen Eintrags zurückgegeben. Dies ist eine Umbenennung von exec().

class PyAPplus64.applus_usexml.UseXmlRowInsertOrUpdate(applus: APplusServer, table: str)

Bases: PyAPplus64.applus_usexml.UseXmlRow

Klasse, die eine XML-Datei für das Einfügen oder Ändern eines neuen Datensatzes, erzeugen kann. Die Methode checkExists erlaubt es zu prüfen, ob ein Objekt bereits existiert. Dafür werden die gesetzten Felder mit den Feldern aus eindeutigen Indices verglichen. Existiert ein Objekt bereits, wird ein Update ausgeführt, ansonsten ein Insert. Bei Updates werden die Felder id und timestamp automatisch gesetzt.

Parameter

  • applus (APplusServer) – Verbindung zu APplus

  • table (string) – die Tabelle

checkExists() → Optional[int]

Prüft, ob der Datensatz bereits in der DB existiert. Ist dies der Fall, wird die ID geliefert, sonst None

exec() → int

Führt entweder ein Update oder ein Insert durch. Dies hängt davon ab, ob das Objekt bereits in der DB existiert. In jedem Fall wird die ID des erzeugten oder geänderten Objekts geliefert.

insert() → int

Führt ein Insert aus. Existiert das Objekt bereits, wird eine Exception geworfen.

update(id: Optional[int] = None, ts: Optional[bytes] = None) → int

Führt ein Update aus. Falls ID oder Timestamp nicht übergeben werden, wird nach einem passenden Objekt gesucht. Existiert das Objekt nicht, wird eine Exception geworfen.

updateOrInsert() → int

Führt das update oder das insert aus. Evtl. wird dabei eine Exception geworfen. Dies ist eine Umbenennung von exec(). Es wird die ID des Eintrages geliefert

class PyAPplus64.applus_usexml.UseXmlRowUpdate(applus: APplusServer, table: str, id: int, ts: Optional[bytes] = None)

Bases: PyAPplus64.applus_usexml.UseXmlRow

Klasse, die eine XML-Datei für das Ändern eines neuen Datensatzes, erzeugen kann. Die Felder id und timestamp werden automatisch gesetzt.

Parameter

  • applus (APplusServer) – Verbindung zu APplus

  • table (string) – die Tabelle

  • id (int) – die ID des zu ändernden Datensatzes

  • ts (bytes optional) – wenn gesetzt, wird dieser Timestamp verwendet, sonst der aktuelle aus der DB

update() → None

Führt das update aus. Evtl. wird dabei eine Exception geworfen. Dies ist eine Umbenennung von exec().

PyAPplus64.duplicate module

Dupliziert ein oder mehrere APplus Business-Objekte

class PyAPplus64.duplicate.DuplicateBusinessObject(table: str, fields: Dict[str, Any], fieldsNotCopied: Dict[str, Any] = {}, allowUpdate: bool = False)

Bases: object

Klasse, die alle Daten zu einem BusinessObject speichert und zum Duplizieren dieses Objektes dient. Dies beinhaltet Daten zu abhängigen Objekten sowie die Beziehung zu diesen Objekten. Zu einem Artikel wird z.B. der Arbeitsplan gespeichert, der wiederum Arbeitsplanpositionen enthält. Als Beziehung ist u.a. hinterlegt, dass das Feld „APLAN“ der Arbeitsplans dem Feld „ARTIKEL“ des Artikels entsprechen muss und dass „APLAN“ aus den Positionen, „APLAN“ aus dem APlan entsprichen muss. So kann beim Duplizieren ein anderer Name des Artikels gesetzt werden und automatisch die Felder der abhängigen Objekte angepasst werden. Einige Felder der Beziehung sind dabei statisch, d.h. können direkt aus den zu speichernden Daten abgelesen werden. Andere Felder sind dynamisch, d.h. das Parent-Objekt muss in der DB angelegt werden, damit ein solcher dynamischer Wert erstellt und geladen werden kann. Ein typisches Beispiel für ein dynamisches Feld ist „GUID“.

addDependentBusinessObject(dObj: Optional[PyAPplus64.duplicate.DuplicateBusinessObject], *args: Tuple[str, str]) → None

Fügt ein neues Unterobjekt zum DuplicateBusinessObject hinzu. Dabei handelt es sich selbst um ein DuplicateBusinessObject, das zusammen mit dem Parent-Objekt dupliziert werden sollen. Zum Beispiel sollen zu einem Auftrag auch die Positionen dupliziert werden. Zusätzlich zum Objekt selbst können mehrere (keine, eine oder viele) Paare von Feldern übergeben werden. Ein Paar („pf“, „sf“) verbindet das Feld „pf“ des Parent-Objekts mit dem Feld „sf“ des Sub-Objekts. So ist es möglich, Werte des Parent-Objekts zu ändern und diese Änderungen für Sub-Objekte zu übernehmen. Üblicherweise muss zum Beispiel die Nummer des Hauptobjekts geändert werden. Die gleiche Änderung ist für alle abhängigen Objekte nötig, damit die neuen Objekte sich auf das Parent-Objekt beziehen.

Parameter

  • dObj (DuplicateBusinessObject) – das Unter-Objekt

  • args – Liste von Tupeln, die Parent- und Sub-Objekt-Felder miteinander verbinden

allowUpdate

Erlaube Updates statt Fehlern, wenn Objekt schon in DB existiert

dependentObjs: List[Dict[str, Any]]

Abhängige Objekte

fields

die Daten

fieldsNotCopied

Datenfelder, die im Original vorhanden sind, aber nicht kopiert werden sollen

getField(field: str, onlyCopied: bool = False) → Any

Schlägt den Wert eines Feldes nach. Wenn onlyCopied gesetzt ist, werden nur Felder zurückgeliefert, die auch kopiert werden sollen.

insert(server: PyAPplus64.applus.APplusServer) → PyAPplus64.applus_db.DBTableIDs

Fügt alle Objekte zur DB hinzu. Es wird die Menge der IDs der erzeugten Objekte gruppiert nach Tabellen erzeugt. Falls ein Datensatz schon existiert, wird dieser entweder aktualisiert oder eine Fehlermeldung geworfen. Geliefert wird die Menge aller Eingefügten Objekte mit ihrer ID.

setFields(upds: Dict[str, Any]) → None

Setzt Felder des DuplicateBusinessObjektes und falls nötig seiner Unterobjekte. So kann zum Beispiel die Nummer vor dem Speichern geändert werden.

Parameter

upds – Dictionary mit zu setzenden Werten

table

für welche Tabelle ist das BusinessObject

class PyAPplus64.duplicate.FieldsToCopyForTableCache(server: PyAPplus64.applus.APplusServer)

Bases: object

Cache für welche Felder für welche Tabelle kopiert werden sollen

getFieldsToCopyForTable(table: str) → Set[str]

Bestimmt die für eine Tabelle zu kopierenden Spalten. Dazu wird in den XML-Definitionen geschaut. Ist dort ‚include‘ hinterlegt, werden diese Spalten verwendet. Ansonsten alle nicht generierten Spalten, ohne die ‚exclude‘ Spalten. In jedem Fall werden Spalten wie „ID“, die nie kopiert werden sollten, entfernt.

PyAPplus64.duplicate.addSachgruppeDependentObjects(do: PyAPplus64.duplicate.DuplicateBusinessObject, server: PyAPplus64.applus.APplusServer, cache: Optional[PyAPplus64.duplicate.FieldsToCopyForTableCache] = None) → None

Fügt Unterobjekte hinzu, die die Sachgruppenwerte kopieren.

Parameter

  • do – zu erweiterndes DuplicateBusinessObject

  • server (APplusServer) – Verbindung zum APP-Server, benutzt zum Nachschlagen der zu kopierenden Felder

  • cache (Optional[FieldsToCopyForTableCache]) – Cache, so dass benötigte Felder nicht immer wieder neu berechnet werden müssen

PyAPplus64.duplicate.getFieldsToCopyForTable(server: PyAPplus64.applus.APplusServer, table: str, force: bool = True) → Set[str]

Bestimmt die für eine Tabelle zu kopierenden Spalten. Dazu wird in den XML-Definitionen geschaut. Ist dort ‚include‘ hinterlegt, werden diese Spalten verwendet. Ansonsten alle nicht generierten Spalten, ohne die ‚exclude‘ Spalten. In jedem Fall werden Spalten wie „ID“, die nie kopiert werden sollten, entfernt.

PyAPplus64.duplicate.initFieldsToCopyForTableCacheIfNeeded(server: PyAPplus64.applus.APplusServer, cache: Optional[PyAPplus64.duplicate.FieldsToCopyForTableCache]) → PyAPplus64.duplicate.FieldsToCopyForTableCache

Hilfsfunktion, die einen Cache erzeugt, falls dies noch nicht geschehen ist.

PyAPplus64.duplicate.loadDBDuplicateAPlan(server: PyAPplus64.applus.APplusServer, aplan: str, cache: Optional[PyAPplus64.duplicate.FieldsToCopyForTableCache] = None) → Optional[PyAPplus64.duplicate.DuplicateBusinessObject]

Erstelle DuplicateBusinessObject für einzelnen Arbeitsplan.

Parameter

  • server (APplusServer) – Verbindung zum APP-Server, benutzt zum Nachschlagen der zu kopierenden Felder

  • aplan (str) – Aplan, der kopiert werden soll.

  • cache (Optional[FieldsToCopyForTableCache]) – Cache, so dass benötigte Felder nicht immer wieder neu berechnet werden müssen

Rückgabe

das neue DuplicateBusinessObject

Rückgabetyp

DuplicateBusinessObject

PyAPplus64.duplicate.loadDBDuplicateArtikel(server: PyAPplus64.applus.APplusServer, artikel: str, cache: Optional[PyAPplus64.duplicate.FieldsToCopyForTableCache] = None, dupAplan: bool = True, dupStueli: bool = True) → Optional[PyAPplus64.duplicate.DuplicateBusinessObject]

Erstelle DuplicateBusinessObject für einzelnen Artikel.

Parameter

  • server (APplusServer) – Verbindung zum APP-Server, benutzt zum Nachschlagen der zu kopierenden Felder

  • artikel (str) – Artikel, der kopiert werden soll

  • cache (Optional[FieldsToCopyForTableCache]) – Cache, so dass benötigte Felder nicht immer wieder neu berechnet werden müssen

  • dupAplan (bool optional) – Arbeitsplan duplizieren?

  • dupStueli (bool optional) – Stückliste duplizieren?

Rückgabe

das neue DuplicateBusinessObject

Rückgabetyp

DuplicateBusinessObject

PyAPplus64.duplicate.loadDBDuplicateBusinessObject(server: PyAPplus64.applus.APplusServer, table: str, cond: PyAPplus64.sql_utils.SqlCondition, cache: Optional[PyAPplus64.duplicate.FieldsToCopyForTableCache] = None, allowUpdate: bool = False) → Optional[PyAPplus64.duplicate.DuplicateBusinessObject]

Läd ein einzelnes DuplicateBusinessObjekt aus der DB. Die Bedingung sollte dabei einen eindeutigen Datensatz auswählen. Werden mehrere zurückgeliefert, wird ein zufälliger ausgewählt. Wird kein Datensatz gefunden, wird None geliefert.

Parameter

  • server (APplusServer) – Verbindung zum APP-Server, benutzt zum Nachschlagen der zu kopierenden Felder

  • table (str) – Tabelle für das neue DuplicateBusinessObjekt

  • cond (sql_utils.SqlCondition) – SQL-Bedingung zur Auswahl eines Objektes

  • cache (Optional[FieldsToCopyForTableCache]) – Cache, so dass benötigte Felder nicht immer wieder neu berechnet werden müssen

  • allowUpdate (bool) – ist Update statt Insert erlaubt?

Rückgabe

das neue DuplicateBusinessObject

Rückgabetyp

Optional[DuplicateBusinessObject]

PyAPplus64.duplicate.loadDBDuplicateBusinessObjectSimpleCond(server: PyAPplus64.applus.APplusServer, table: str, field: str, value: Optional[Union[str, int, float, PyAPplus64.sql_utils.SqlParam, PyAPplus64.sql_utils.SqlField, PyAPplus64.sql_utils.SqlFixed, PyAPplus64.sql_utils.SqlDate, PyAPplus64.sql_utils.SqlDateTime, datetime.datetime, datetime.date, datetime.time, bool]], cache: Optional[PyAPplus64.duplicate.FieldsToCopyForTableCache] = None, allowUpdate: bool = False) → Optional[PyAPplus64.duplicate.DuplicateBusinessObject]

Wrapper für loadDBDuplicateBusinessObject, das eine einfache Bedingung benutzt, bei der ein Feld einen bestimmten Wert haben muss.

Parameter

  • server (APplusServer) – Verbindung zum APP-Server, benutzt zum Nachschlagen der zu kopierenden Felder

  • table (str) – Tabelle für das neue DuplicateBusinessObjekt

  • field (str) – Feld für Bedingung

  • value – Wert des Feldes für Bedingung

  • cache (Optional[FieldsToCopyForTableCache]) – Cache, so dass benötigte Felder nicht immer wieder neu berechnet werden müssen

Rückgabe

das neue DuplicateBusinessObject

Rückgabetyp

Optional[DuplicateBusinessObject]

PyAPplus64.duplicate.loadDBDuplicateBusinessObjects(server: PyAPplus64.applus.APplusServer, table: str, cond: PyAPplus64.sql_utils.SqlCondition, cache: Optional[PyAPplus64.duplicate.FieldsToCopyForTableCache] = None, allowUpdate: bool = False) → Sequence[PyAPplus64.duplicate.DuplicateBusinessObject]

Läd eine Liste von DuplicateBusinessObjekten aus der DB. Die Bedingung kann mehrere Datensätze auswählen.

Parameter

  • server (APplusServer) – Verbindung zum APP-Server, benutzt zum Nachschlagen der zu kopierenden Felder

  • table (str) – Tabelle für das neue DuplicateBusinessObjekt

  • cond (sql_utils.SqlCondition) – SQL-Bedingung zur Auswahl eines Objektes

  • cache (Optional[FieldsToCopyForTableCache]) – Cache, so dass benötigte Felder nicht immer wieder neu berechnet werden müssen

Rückgabe

Liste der neuen DuplicateBusinessObjects

Rückgabetyp

Sequence[DuplicateBusinessObject]

PyAPplus64.duplicate.loadDBDuplicateBusinessObjectsSimpleCond(server: PyAPplus64.applus.APplusServer, table: str, field: str, value: Optional[Union[str, int, float, PyAPplus64.sql_utils.SqlParam, PyAPplus64.sql_utils.SqlField, PyAPplus64.sql_utils.SqlFixed, PyAPplus64.sql_utils.SqlDate, PyAPplus64.sql_utils.SqlDateTime, datetime.datetime, datetime.date, datetime.time, bool]], cache: Optional[PyAPplus64.duplicate.FieldsToCopyForTableCache] = None, allowUpdate: bool = False) → Sequence[PyAPplus64.duplicate.DuplicateBusinessObject]

Wrapper für loadDBDuplicateBusinessObjects, das eine einfache Bedingung benutzt, bei der ein Feld einen bestimmten Wert haben muss.

Parameter

  • server (APplusServer) – Verbindung zum APP-Server, benutzt zum Nachschlagen der zu kopierenden Felder

  • table (str) – Tabelle für das neue DuplicateBusinessObjekt

  • field – Feld für Bedingung

  • value – Wert des Feldes für Bedingung

  • cache (Optional[FieldsToCopyForTableCache]) – Cache, so dass benötigte Felder nicht immer wieder neu berechnet werden müssen

Rückgabe

Liste der neuen DuplicateBusinessObjects

Rückgabetyp

Sequence[DuplicateBusinessObject]

PyAPplus64.duplicate.loadDBDuplicateStueli(server: PyAPplus64.applus.APplusServer, stueli: str, cache: Optional[PyAPplus64.duplicate.FieldsToCopyForTableCache] = None) → Optional[PyAPplus64.duplicate.DuplicateBusinessObject]

Erstelle DuplicateBusinessObject für einzelne Stückliste.

Parameter

  • server (APplusServer) – Verbindung zum APP-Server, benutzt zum Nachschlagen der zu kopierenden Felder

  • stueli (str) – Stückliste, die kopiert werden soll.

  • cache (Optional[FieldsToCopyForTableCache]) – Cache, so dass benötigte Felder nicht immer wieder neu berechnet werden müssen

Rückgabe

das neue DuplicateBusinessObject

Rückgabetyp

Optional[DuplicateBusinessObject]

PyAPplus64.duplicate.noCopyFields = {'GUID', 'ID', 'ID_A', 'INSDATE', 'INSUSER', 'MANDANT', 'TIMESTAMP', 'TIMESTAMP_A', 'UPDDATE', 'UPDUSER'}

Menge von Feld-Namen, die nie kopiert werden sollen.

PyAPplus64.pandas module

Pandas Interface für PyAPplus64.

PyAPplus64.pandas.createSqlAlchemyEngine(server: PyAPplus64.applus.APplusServer) → sqlalchemy.engine.base.Engine

Erzeugt eine SqlAlchemy-Engine für die Verbindung zur DB.

PyAPplus64.pandas.exportToExcel(filename: Union[str, PathLike[str], pandas._typing.WriteExcelBuffer, pandas.io.excel._base.ExcelWriter], dfs: Sequence[Tuple[pandas.core.frame.DataFrame, str]], addTable: bool = True) → None

Schreibt eine Menge von Dataframes in eine Excel-Tabelle

Parameter

  • filename – Name der Excel-Datei

  • dfs – Liste von Tupeln aus DataFrames und Namen von Sheets.

PyAPplus64.pandas.mkDataframeColumn(df: pandas.core.frame.DataFrame, makeValue: Union[Callable, str, List[Union[Callable, str]], Dict[Hashable, Union[Callable, str, List[Union[Callable, str]]]]]) → pandas.core.series.Series

Erzeugt für alle Zeilen eines Dataframes eine neuen Wert. Dies wird benutzt, um eine Spalte zu berechnen. Diese kann eine Originalspalte ersetzen, oder neu hinzugefügt werden.

Parameter

  • df – der Dataframe

  • makeValue – Funktion, die eine Zeile als Parameter bekommt und den neuen Wert berechnet

PyAPplus64.pandas.mkHyperlinkDataframeColumn(df: pandas.core.frame.DataFrame, makeOrig: Union[Callable, str, List[Union[Callable, str]], Dict[Hashable, Union[Callable, str, List[Union[Callable, str]]]]], makeLink: Callable[[Any], str]) → pandas.core.series.Series

Erzeugt für alle Zeilen eines Dataframes einen Hyperlink. Dies wird benutzt, um eine Spalte mit einem Hyperlink zu berechnen. Diese kann eine Originalspalte ersetzen, oder neu hinzugefügt werden.

Parameter

  • df – der Dataframe

  • makeOrig – Funktion, die eine Zeile als Parameter bekommt und den Wert berechnet, der angezeigt werden soll

  • makeLink – Funktion, die eine Zeile als Parameter bekommt und den Link berechnet

PyAPplus64.pandas.pandasReadSql(server: PyAPplus64.applus.APplusServer, sql: Union[PyAPplus64.sql_utils.SqlStatementSelect, str], raw: bool = False, engine: Optional[sqlalchemy.engine.base.Engine] = None) → pandas.core.frame.DataFrame

Wrapper für pd.read_sql für sqlalchemy-engine.

Parameter

  • server (APplusServer) – APplusServer für Datenbankverbindung und complete-SQL

  • sql – das SQL-statement

PyAPplus64.sql_utils module

Diese Datei enthält Funktionen für den Bau von SQL Statements, besonders SELECT-Statements. Es gibt viel ausgefeiltere Methoden für die Erstellung von SQL Statements. APplus benötigt jedoch die Statements als Strings, die dann an APplus für Änderungen und erst danach an die DB geschickt werden. Dies erschwert die Nutzung von Tools wie SqlAlchemy.

Hier werden einfache Hilfsfunktionen, die auf Strings basieren, zur Verfügung gestellt. PyODBC erlaubt Parameter (dargestellt als ‚?‘) in SQL Statements, die dann beim Aufruf gefüllt werden. Dies funktioniert auch im Zusammenspiel mit APplus. Oft ist es sinnvoll, solche Parameter zu verwenden.

class PyAPplus64.sql_utils.SqlCondition

Bases: object

Eine abstrakte Sql-Bedingung. Unterklassen erledigen die eigentliche Arbeit.

getCondition() → str

Liefert die Bedingung als String

Rückgabe

die Bedingung

Rückgabetyp

str

class PyAPplus64.sql_utils.SqlConditionAnd(*conds: Union[PyAPplus64.sql_utils.SqlCondition, str])

Bases: PyAPplus64.sql_utils.SqlConditionList

class PyAPplus64.sql_utils.SqlConditionBinComp(op: str, value1: SqlValue, value2: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Bedingung der Form ‚value1 op value2‘

Parameter

  • op (str) – der Vergleichsoperator

  • value1 (SqlValue) – der Wert, kann unterschiedliche Typen besitzen

  • value2 (SqlValue) – der Wert, kann unterschiedliche Typen besitzen

class PyAPplus64.sql_utils.SqlConditionBool(b: bool)

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Fixe True-oder-False Bedingung

class PyAPplus64.sql_utils.SqlConditionDateTimeFieldInDay(field: str, year: int, month: int, day: int)

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Liegt Datetime in einem bestimmten Monat?

Parameter

  • field (str) – das Feld

  • year – das Jahr

  • month – der Monat

  • day – der Tag

class PyAPplus64.sql_utils.SqlConditionDateTimeFieldInMonth(field: str, year: int, month: int)

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Liegt Datetime in einem bestimmten Monat?

Parameter

  • field (string) – das Feld

  • year – das Jahr

  • month – der Monat

class PyAPplus64.sql_utils.SqlConditionDateTimeFieldInRange(field: str, datetimeVon: Optional[datetime.datetime], datetimeBis: Optional[datetime.datetime])

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Liegt Datetime in einem bestimmten Zeitraum?

Parameter

  • field (str) – das Feld

  • datetimeVon – der untere Wert (einschließlich), None erlaubt beliebige Zeiten

  • datetimeBis – der obere Wert (ausschließlich), None erlaubt beliebige Zeiten

class PyAPplus64.sql_utils.SqlConditionDateTimeFieldInYear(field: str, year: int)

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Liegt Datetime in einem bestimmten Jahr?

Parameter

  • field (str) – das Feld

  • year – das Jahr

class PyAPplus64.sql_utils.SqlConditionEq(value1: Union[SqlValue, bool, None], value2: Union[SqlValue, bool, None])

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Bedingung der Form ‚v1 is null‘, ‚v2 is null‘, ‚v1 = v2‘, ‚(1=1)‘ oder ‚(0=1)‘

Parameter

  • value1 – der Wert, kann unterschiedliche Typen besitzen

  • value2 – der Wert, kann unterschiedliche Typen besitzen

class PyAPplus64.sql_utils.SqlConditionFalse

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

False-Bedingung

class PyAPplus64.sql_utils.SqlConditionFieldEq(field: str, value: Union[SqlValue, bool, None])

Bases: PyAPplus64.sql_utils.SqlConditionEq

class PyAPplus64.sql_utils.SqlConditionFieldGe(field: str, value: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionGe

class PyAPplus64.sql_utils.SqlConditionFieldGt(field: str, value: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionGt

class PyAPplus64.sql_utils.SqlConditionFieldIn

Bases: PyAPplus64.sql_utils.SqlConditionIn

class PyAPplus64.sql_utils.SqlConditionFieldIsNotNull(field: str)

Bases: PyAPplus64.sql_utils.SqlConditionIsNotNull

class PyAPplus64.sql_utils.SqlConditionFieldIsNull(field: str)

Bases: PyAPplus64.sql_utils.SqlConditionIsNull

class PyAPplus64.sql_utils.SqlConditionFieldLe(field: str, value: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionLe

class PyAPplus64.sql_utils.SqlConditionFieldLt(field: str, value: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionLt

class PyAPplus64.sql_utils.SqlConditionFieldStringNotEmpty(field: str)

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Feld soll nicht den leeren String oder null enthalten. Der Ausdruck wird wörtlich übernommen.

Parameter

field (str) – das Feld

class PyAPplus64.sql_utils.SqlConditionGe(value1: SqlValue, value2: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionBinComp

Bedingung der Form ‚value1 >= value2‘

Parameter

  • value1 – der Wert, kann unterschiedliche Typen besitzen

  • value2 – der Wert, kann unterschiedliche Typen besitzen

class PyAPplus64.sql_utils.SqlConditionGt(value1: SqlValue, value2: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionBinComp

Bedingung der Form ‚value1 > value2‘

Parameter

  • value1 – der Wert, kann unterschiedliche Typen besitzen

  • value2 – der Wert, kann unterschiedliche Typen besitzen

class PyAPplus64.sql_utils.SqlConditionIn

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Bedingung der Form ‚v in …‘

Parameter

  • value (SqlValue) – der Wert, kann unterschiedliche Typen besitzen

  • values (Sequence[SqlValue]) – die erlaubten Werte

class PyAPplus64.sql_utils.SqlConditionIsNotNull(v: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Wert soll nicht null sein

Parameter

v (SqlValue) – der Wert

class PyAPplus64.sql_utils.SqlConditionIsNull(v: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Wert soll null sein

Parameter

v (SqlValue) – das Feld

class PyAPplus64.sql_utils.SqlConditionLe(value1: SqlValue, value2: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionBinComp

Bedingung der Form ‚value1 <= value2‘

Parameter

  • value1 – der Wert, kann unterschiedliche Typen besitzen

  • value2 – der Wert, kann unterschiedliche Typen besitzen

class PyAPplus64.sql_utils.SqlConditionList(connector: str, emptyCond: str)

Bases: PyAPplus64.sql_utils.SqlCondition

Eine SQL Bedingung, die sich aus einer Liste anderer Bedingungen zusammensetzen. Dies kann eine „AND“ oder eine „OR“ Liste sein.

Parameter

  • connector (str) – wie werden Listenelemente verbunden (AND oder OR)

  • emptyCond (str) – Rückgabewert für leere Liste

addCondition(cond: Optional[Union[PyAPplus64.sql_utils.SqlCondition, str]]) → None
addConditionEq(value1: Union[SqlValue, bool, None], value2: Union[SqlValue, bool, None]) → None
addConditionFieldEq(field: str, value: Union[SqlValue, bool, None]) → None
addConditionFieldGe(field: str, value: SqlValue) → None
addConditionFieldGt(field: str, value: SqlValue) → None
addConditionFieldIn()
addConditionFieldIsNotNull(field: str) → None
addConditionFieldIsNull(field: str) → None
addConditionFieldLe(field: str, value: SqlValue) → None
addConditionFieldLt(field: str, value: SqlValue) → None
addConditionFieldStringNotEmpty(field: str) → None
addConditionFieldsEq(field1: str, field2: str) → None
addConditionFieldsGe(field1: str, field2: str) → None
addConditionFieldsGt(field1: str, field2: str) → None
addConditionFieldsLe(field1: str, field2: str) → None
addConditionFieldsLt(field1: str, field2: str) → None
addConditionGe(value1: SqlValue, value2: SqlValue) → None
addConditionGt(value1: SqlValue, value2: SqlValue) → None
addConditionLe(value1: SqlValue, value2: SqlValue) → None
addConditionLt(value1: SqlValue, value2: SqlValue) → None
addConditions(*conds: Optional[Union[PyAPplus64.sql_utils.SqlCondition, str]]) → None
getCondition() → str

Liefert die Bedingung als String

Rückgabe

die Bedingung

Rückgabetyp

str

isEmpty() → bool
class PyAPplus64.sql_utils.SqlConditionLt(value1: SqlValue, value2: SqlValue)

Bases: PyAPplus64.sql_utils.SqlConditionBinComp

Bedingung der Form ‚value1 < value2‘

Parameter

  • value1 – der Wert, kann unterschiedliche Typen besitzen

  • value2 – der Wert, kann unterschiedliche Typen besitzen

class PyAPplus64.sql_utils.SqlConditionNot(cond: PyAPplus64.sql_utils.SqlCondition)

Bases: PyAPplus64.sql_utils.SqlCondition

Negation einer anderen Bedingung

Parameter

cond (SqlCondition) – die zu negierende Bedingung

getCondition() → str

Liefert die Bedingung als String

Rückgabe

die Bedingung

Rückgabetyp

str

class PyAPplus64.sql_utils.SqlConditionOr(*conds: Union[PyAPplus64.sql_utils.SqlCondition, str])

Bases: PyAPplus64.sql_utils.SqlConditionList

class PyAPplus64.sql_utils.SqlConditionPrepared(cond: Union[PyAPplus64.sql_utils.SqlCondition, str])

Bases: PyAPplus64.sql_utils.SqlCondition

Eine einfache Sql-Bedingung, die immer einen festen String zurückgibt.

getCondition() → str

Liefert die Bedingung als String

Rückgabe

die Bedingung

Rückgabetyp

str

class PyAPplus64.sql_utils.SqlConditionStringStartsWith(field: str, value: str)

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

Feld soll mit einem bestimmten String beginnen

Parameter

  • field (str) – das Feld

  • value (str) – der Wert

class PyAPplus64.sql_utils.SqlConditionTrue

Bases: PyAPplus64.sql_utils.SqlConditionPrepared

True-Bedingung

class PyAPplus64.sql_utils.SqlDate(d: Union[datetime.datetime, datetime.date] = datetime.datetime(2023, 11, 13, 12, 53, 12, 768288))

Bases: object

Wrapper um DateTime, die die Formatierung erleichtern

Parameter

d (Union[datetime.datetime, datetime.date]) – das Datum

class PyAPplus64.sql_utils.SqlDateTime(dt: Union[datetime.datetime, datetime.date] = datetime.datetime(2023, 11, 13, 12, 53, 12, 768274))

Bases: object

Wrapper um DateTime, die die Formatierung erleichtern

Parameter

dt (Union[datetime.datetime, datetime.date]) – der Zeitpunkt

class PyAPplus64.sql_utils.SqlField(fn: str)

Bases: object

Wrapper um SQL Feldnamen, die die Formatierung erleichtern

Parameter

fn (str) – der Feldname

class PyAPplus64.sql_utils.SqlFixed(s: str)

Bases: object

Wrapper um Strings, die ohne Änderung in SQL übernommen werden

Parameter

s (str) – der string

class PyAPplus64.sql_utils.SqlInnerJoin(table: str, *conds: Union[PyAPplus64.sql_utils.SqlCondition, str])

Bases: PyAPplus64.sql_utils.SqlJoin

Ein Inner-Join.

Parameter

  • table (str) – die Tabelle, die gejoint werden soll

  • conds – Bedingungen, die bereits hinzugefügt werden soll. Weitere können über Attribut on hinzugefügt werden.

class PyAPplus64.sql_utils.SqlJoin(joinType: str, table: str, *conds: Union[PyAPplus64.sql_utils.SqlCondition, str])

Bases: object

Ein abstrakter Sql-Join

Parameter

  • joinType (str) – Art des Joins, wird in SQL übernommen, z.B. „LEFT JOIN“.

  • table (str) – die Tabelle, die gejoint werden soll

  • conds – Bedingungen, die bereits hinzugefügt werden soll. Weitere können über Attribut on hinzugefügt werden.

getJoin() → str

Liefert den Join als String

on: PyAPplus64.sql_utils.SqlConditionAnd

Bedingung des Joins, kann noch nachträglich erweitert werden

class PyAPplus64.sql_utils.SqlLeftJoin(table: str, *conds: Union[PyAPplus64.sql_utils.SqlCondition, str])

Bases: PyAPplus64.sql_utils.SqlJoin

Ein Left-Join.

Parameter

  • table (str) – die Tabelle, die gejoint werden soll

  • conds – Bedingungen, die bereits hinzugefügt werden soll. Weitere können über Attribut on hinzugefügt werden.

class PyAPplus64.sql_utils.SqlParam

Bases: object

Hilfsklasse, für einen Parameter (?)

class PyAPplus64.sql_utils.SqlStatementSelect(table: str, *fields: str)

Bases: object

Klasse, um einfache Select-Statements zu bauen.

Parameter

  • table (str) – die Haupt-Tabelle

  • fields – kein oder mehrere Felder, die selektiert werden sollen

addFields(*fields: str) → None

Fügt ein oder mehrere Felder, also auszuwählende Werte zu einem SQL-Statement hinzu.

addFieldsTable(table: str, *fields: str) → None

Fügt ein oder mehrere Felder, die zu einer Tabelle gehören zu einem SQL-Statement hinzu. Felder sind Strings. Vor jeden dieser Strings wird die Tabelle mit einem Punkt getrennt gesetzt. Dies kann im Vergleich zu ‚addFields‘ Schreibarbeit erleitern.

addGroupBy(*fields: str) → None

Fügt ein oder mehrere GroupBy Felder zu einem SQL-Statement hinzu.

addInnerJoin(table: str, *conds: Union[PyAPplus64.sql_utils.SqlCondition, str]) → PyAPplus64.sql_utils.SqlInnerJoin
addJoin(j: Union[PyAPplus64.sql_utils.SqlJoin, str]) → None

Fügt ein Join zum SQL-Statement hinzu. Beispiel: ‚LEFT JOIN personal p ON t.UPDUSER = p.PERSONAL‘

addLeftJoin(table: str, *conds: Union[PyAPplus64.sql_utils.SqlCondition, str]) → PyAPplus64.sql_utils.SqlLeftJoin
fields: List[str]

Liste von auszuwählenden Feldern

getSql() → str

Liefert das SQL-SELECT-Statement als String

groupBy: List[str]

die Bedingung, Default ist True

having: PyAPplus64.sql_utils.SqlConditionList

die Bedingung having, Default ist True

joins: List[Union[PyAPplus64.sql_utils.SqlJoin, str]]

Joins mit extra Tabellen

order: Optional[str]

Sortierung

setTop(t: int) → None

Wie viele Datensätze sollen maximal zurückgeliefert werden? 0 für alle

table: str

die Tabelle

top: int

wie viele Datensätze auswählen? 0 für alle

where: PyAPplus64.sql_utils.SqlConditionList

die Bedingung, Default ist True

class PyAPplus64.sql_utils.SqlTime(t: Union[datetime.datetime, datetime.time] = datetime.datetime(2023, 11, 13, 12, 53, 12, 768295))

Bases: object

Wrapper um DateTime, die die Formatierung erleichtern

Parameter

t (Union[datetime.datetime, datetime.time]) – die Zeit

PyAPplus64.sql_utils.SqlValue

Union-Type aller unterstützter SQL-Werte

alias of Union[str, int, float, PyAPplus64.sql_utils.SqlParam, PyAPplus64.sql_utils.SqlField, PyAPplus64.sql_utils.SqlFixed, PyAPplus64.sql_utils.SqlDate, PyAPplus64.sql_utils.SqlDateTime, datetime.datetime, datetime.date, datetime.time]

PyAPplus64.sql_utils.formatSqlValue(v: SqlValue) → str

Formatiert einen Wert für SQL. Je nachdem um welchen Typ es sich handelt, werden andere Formatierungen verwendet.

Parameter

v (SqlValue) – der Wert

Rückgabe

der formatierte Wert

Rückgabetyp

str

PyAPplus64.sql_utils.formatSqlValueString(s: str) → str

Formatiert einen String für ein Sql-Statement. Der String wird in „‘“ eingeschlossen und Hochkomma im Text maskiert.

Parameter

s (str) – der String

Rückgabe

der formatierte String

Rückgabetyp

str

PyAPplus64.sql_utils.normaliseDBfield(f: str) → str

Normalisiert die Darstellung eines DB-Feldes

PyAPplus64.sql_utils.normaliseDBfieldList(fields: Sequence[str]) → Sequence[str]

Normalisiert eine Menge von DB-Feldern

PyAPplus64.sql_utils.normaliseDBfieldSet(s: Set[str]) → Set[str]

Normalisiert eine Menge von DB-Feldern

PyAPplus64.sql_utils.sqlParam = <PyAPplus64.sql_utils.SqlParam object>

Da SqlParam keinen Zustand hat, reicht ein einzelner statischer Wert

PyAPplus64.utils module

PyAPplus64.utils.checkDirExists(dir: Union[str, pathlib.Path]) → pathlib.Path

Prüft, ob ein Verzeichnis existiert. Ist dies nicht möglich, wird eine Exception geworfen.

Parameter

dir (Union[str, pathlib.Path]) – das Verzeichnis

Rückgabe

den normalisierten Pfad

Rückgabetyp

pathlib.Path

PyAPplus64.utils.containsOnlyAllowedChars(charset: Set[str], s: str) → bool

Enthält ein String nur erlaubte Zeichen?

PyAPplus64.utils.formatDateTimeForAPplus(v: Union[datetime.datetime, datetime.date, datetime.time]) → str

Formatiert ein Datum oder eine Uhrzeit für APplus

Module contents