From f6e0fec07184e2839bd74da62fa812f12767c904 Mon Sep 17 00:00:00 2001 From: Ulrich Carmesin Date: Thu, 16 Dec 2021 01:46:04 +0100 Subject: [PATCH] xml build json --- {ulrich => basic}/__init__.py | 0 {ulrich => basic}/componentHandling.py | 0 {ulrich => basic}/message.py | 0 {ulrich => basic}/program.py | 6 +- {ulrich => basic}/toolHandling.py | 0 components/{testrun.py => testexec.py} | 0 test/test_xml.py | 72 +++ utils/xml_tool.py | 617 +++++++++++++++++++++++++ 8 files changed, 692 insertions(+), 3 deletions(-) rename {ulrich => basic}/__init__.py (100%) rename {ulrich => basic}/componentHandling.py (100%) rename {ulrich => basic}/message.py (100%) rename {ulrich => basic}/program.py (98%) rename {ulrich => basic}/toolHandling.py (100%) rename components/{testrun.py => testexec.py} (100%) create mode 100644 test/test_xml.py create mode 100644 utils/xml_tool.py diff --git a/ulrich/__init__.py b/basic/__init__.py similarity index 100% rename from ulrich/__init__.py rename to basic/__init__.py diff --git a/ulrich/componentHandling.py b/basic/componentHandling.py similarity index 100% rename from ulrich/componentHandling.py rename to basic/componentHandling.py diff --git a/ulrich/message.py b/basic/message.py similarity index 100% rename from ulrich/message.py rename to basic/message.py diff --git a/ulrich/program.py b/basic/program.py similarity index 98% rename from ulrich/program.py rename to basic/program.py index 1ed5f02..b4d6bd9 100644 --- a/ulrich/program.py +++ b/basic/program.py @@ -38,19 +38,19 @@ jobdef = { "pfilesource" : "tsparfile", "pfiletarget" : "tcparfile", "basedir": "tcbase", - "logdir": "{job.par.tcdir}/{log}/log_{tctime}.txt" } + "logdir": "{job.par.tcdir}/{log}/log_{tctime}.txt" }, "test_system": { "pardef": "tcdir,tdtyp,tdsrc,tdname", "pfilesource": "tsparfile", "pfiletarget": "tcparfile", "basedir": "tcbase", - "logdir": "{job.par.tcdir}/{log}/log_{tctime}.txt"} + "logdir": "{job.par.tcdir}/{log}/log_{tctime}.txt"}, "finish_testcase": { "pardef": "tcdir,tdtyp,tdsrc,tdname", "pfilesource": "tsparfile", "pfiletarget": "tcparfile", "basedir": "tcbase", - "logdir": "{job.par.tcdir}/{log}/log_{tctime}.txt"} + "logdir": "{job.par.tcdir}/{log}/log_{tctime}.txt"}, "finish_testset": { "pardef": "tcdir,tdtyp,tdsrc,tdname", "pfilesource": "tsparfile", diff --git a/ulrich/toolHandling.py b/basic/toolHandling.py similarity index 100% rename from ulrich/toolHandling.py rename to basic/toolHandling.py diff --git a/components/testrun.py b/components/testexec.py similarity index 100% rename from components/testrun.py rename to components/testexec.py diff --git a/test/test_xml.py b/test/test_xml.py new file mode 100644 index 0000000..3544476 --- /dev/null +++ b/test/test_xml.py @@ -0,0 +1,72 @@ +import unittest +#import basic.program +import utils.xml_tool +import utils.xml_tool + +class MyTestCase(unittest.TestCase): + def xtest_xmlTool(self): + #job = basic.program.Job("unit") + args = {"application": "TEST", "application": "ENV01", "modus": "unit", "loglevel": "debug", + "tool": "job_tool", "tdtyp": "csv", "tdsrc": "implement", "tdname": "firstunit", + "modus": "unit"} + beispiel_json = {'root': {'@attr': 'xyz', '$': 'inhalt', "b": "bold"}} + tree = {} + tree["root"] = args + xml = utils.xml_tool.dict2xml(tree) + print(xml) + xml = utils.xml_tool.dict2xml(beispiel_json) + print(xml) + self.assertEqual(1, 1) + f = utils.xml_tool.fcts() + + def xtest_addSingle(self): + tree = {} + # tree = utils.xml_tool.fcts.addMerkmal(tree, '/root/datensegment/satz[@klasse="4711x"]/mm[@name="NAME"]/wert', 2, "abc") + tree = utils.xml_tool.fcts.addMerkmal(tree, '/root/datensegment/kratz/mm[@name="NAME"]/wert', 2, "abc") + self.assertEqual(tree["kratz"]["mm"][0]["wert"], "abc") + self.assertEqual(tree["kratz"]["mm"][0]["@name"], "NAME") + + def xtest_addTwo(self): + # a-b-b + # c-a-a c-a-b + tree = {} + print("--------------------------------------------------------------------------------") + tree = utils.xml_tool.fcts.addMerkmal(tree, '/root/datensegment/kratz/mm[@name="NAME"]/wert', 2, "abc") + print("--------------------------------------------------------------------------------") + tree = utils.xml_tool.fcts.addMerkmal(tree, '/root/datensegment/kratz/mm[@name="LAND"]/wert', 2, "xyz") + baum = {} + baum["root"] = tree + print("<------"+str(baum["root"])) + self.assertEqual(tree["kratz"]["mm"][0]["wert"], "abc") + self.assertEqual(tree["kratz"]["mm"][0]["@name"], "NAME") + self.assertEqual(tree["kratz"]["mm"][1]["wert"], "xyz") + self.assertEqual(tree["kratz"]["mm"][1]["@name"], "LAND") + + def xtest_addOnePaths(self): + tree = {} + print("--------------------------------------------------------------------------------") + tree = utils.xml_tool.fcts.setMerkmal(tree, '/root/datensegment/satz[@klasse="4711x"]/mm[@name="NAME"]/wert', "abc") + baum = {} + baum["root"] = tree + print("<------"+str(baum["root"])) + self.assertEqual(tree["root"]["datensegment"]["satz"][0]["mm"][0]["wert"], "abc") + self.assertEqual(tree["root"]["datensegment"]["satz"][0]["mm"][0]["@name"], "NAME") + self.assertEqual(tree["root"]["datensegment"]["satz"][0]["@klasse"], "4711x") + + def test_addTwoPaths(self): + tree = {} + print("--------------------------------------------------------------------------------") + tree = utils.xml_tool.fcts.setMerkmal(tree, '/root/datensegment/satz[@klasse="4711x"]/mm[@name="NAME"]/wert', "abc") + print("--------------------------------------------------------------------------------") + tree = utils.xml_tool.fcts.setMerkmal(tree, '/root/datensegment/satz[@klasse="4711x"]/mm[@name="LAND"]/wert', "xyz") + baum = {} + baum["root"] = tree + print("<------"+str(baum["root"])) + self.assertEqual(tree["root"]["datensegment"]["satz"][0]["mm"][0]["wert"], "abc") + self.assertEqual(tree["root"]["datensegment"]["satz"][0]["mm"][0]["@name"], "NAME") + self.assertEqual(tree["root"]["datensegment"]["satz"][0]["@klasse"], "4711x") + + +if __name__ == '__main__': + unittest.main() + diff --git a/utils/xml_tool.py b/utils/xml_tool.py new file mode 100644 index 0000000..ce88539 --- /dev/null +++ b/utils/xml_tool.py @@ -0,0 +1,617 @@ +#import dpath.util +import json +import yaml +import re +import datetime +#from tools.reader import fcts as reader +import os, sys, json +import xmltodict +import pprint + +#class fcts: +def dict2xml(tree): + out = xmltodict.unparse(tree, pretty=True) + return out + +def xml2dict(xmlstring): + tree = {} + pp = pprint.PrettyPrinter(indent=4) + tree = xmlstring.parse(xmlstring) + return tree + +""" +Register-Meldung erstellen +""" +class register(): + def __init__(self): + self.absender = Absender() + self.vrfelder = Vrfelder() + pass + + def schreibeRegister(self, content, regAdr): + ausgabe = {} + content["vrfelder"] = self.vrfelder + content["absender"] = self.absender.keys[regAdr] + # + ausgabe = self.schreibeProtokoll(ausgabe, content) + print( "ausgabe vorher: " + str( ausgabe)) + ausgabe = self.schreibeAbsender(ausgabe, content, regAdr) + print("ausgabe vorher: "+str(ausgabe)) + ausgabe = self.schreibeEmpfaenger(ausgabe, content) + print("ausgabe vorher: "+str(ausgabe)) + ausgabe = self.schreibeMetadaten(ausgabe, content) + print("ausgabe vorher: "+str(ausgabe)) + ausgabe = self.schreibeSegmentkopf(ausgabe, content) + print("ausgabe vorher: "+str(ausgabe)) + ausgabe["nachricht"]["datensegment"] = [] + for row in content["tabelle"]["person"]["_data"]: + print ("foreach row") + print (row) + satz = {} + satz = self.schreibeSegmentsatz(satz, content, row["_lfdNR"]) + # print("ausgabe vorher: "+str(ausgabe)) + ausgabe["nachricht"]["datensegment"].append(satz["datensegment"]) + return ausgabe + + """ Fuellt und ordnet Protokollknoten ein""" + def schreibeProtokoll(self, ausgabe, content): + ausgabe["protokoll"] = self.setProtokoll(content)["protokoll"] + return ausgabe + + def setProtokoll(self, content): + ausgabe = {} + d = datetime.datetime.now() + ausgabe = fcts.setMerkmal(ausgabe, '/protokoll/dokumentinstanz/datum', d.strftime("%Y%m%d")) + ausgabe = fcts.setMerkmal(ausgabe, '/protokoll/dokumentinstanz/uhrzeit', d.strftime("%H%M%S")) + ausgabe = fcts.setMerkmal(ausgabe, '/protokoll/dokumentinstanz/anwendung/anwendungsname', "Anwendungsname") + ausgabe = fcts.setMerkmal(ausgabe, '/protokoll/dokumentinstanz/anwendung/version', "Version") + ausgabe = fcts.setMerkmal(ausgabe, '/protokoll/dokumentinstanz/anwendung/hersteller', "StBA") + ausgabe = fcts.setMerkmal(ausgabe, '/protokoll/dokumentinstanz/ressourceID[@klasse="SDFMETA"]', "--RessourceID") + return ausgabe + + """ Fuellt und ordnet Absenderknoten ein""" + def schreibeAbsender(self, ausgabe, content, regAdr): + ausgabe["absender"] = self.setAbsender(content, regAdr) + return ausgabe + + def setAbsender(self, content, regAdr): + ausgabe = {} + for feld in Absender.FELDER: + ausgabe = fcts.setMerkmalContent(ausgabe, content, 0, feld) + return ausgabe + + """ Fuellt und ordnet Empfaengerknoten ein""" + def schreibeEmpfaenger(self, ausgabe, content): + ausgabe["empfaenger"] = self.setEmpfaenger(content)["empfaenger"] + return ausgabe + + def setEmpfaenger(self, content): + ausgabe = {} + ausgabe = fcts.setMerkmal(ausgabe, '/empfaenger/kennung[@klasse="STAID"]', '99') + return ausgabe + + """ Fuellt und ordnet Metadatenknoten ein""" + def schreibeMetadaten(self, ausgabe, content): + nachricht = self.setMetadaten(content) + for knoten in nachricht: + if knoten != "datensegment": + ausgabe[knoten] = nachricht[knoten] + return ausgabe + + def setMetadaten(self, content): + ausgabe = {} + d = datetime.datetime.now() + ausgabe = fcts.setMerkmal(ausgabe, '/nachricht/erhebung/kennung[@klasse="ERHID"]', 'ERHEBUNG_KENNUNG') + ausgabe = fcts.setMerkmal(ausgabe, '/nachricht/erhebung/ressource[@klasse="SDFMETA"]', 'ERHEBUNG_RESSOURCE_1') + ausgabe = fcts.setMerkmal(ausgabe, '/nachricht/erhebung/ressource[@klasse="SDF-ERZEUGUNG"]', 'ERHEBUNG_RESSOURCE_2') + ausgabe = fcts.setMerkmal(ausgabe, '/nachricht/berichtszeitraum/jahr', d.strftime("%Y")) + ausgabe = fcts.setMerkmal(ausgabe, '/nachricht/berichtsempfaenger/kennung[@klasse ="STAID"]', 'BERICHTSEMPFÄNGER_KENNUNG') + ausgabe = fcts.setMerkmal(ausgabe, '/nachricht/datenattribute/attribute::dezimalzeichen', 'DEZIMAL_ZEICHEN') + ausgabe = fcts.setMerkmal(ausgabe, '/nachricht/datenattribute/attribute::tausender-trennzeichen', 'TAUSENDER_TRENNZEICHEN') + ausgabe = fcts.setMerkmal(ausgabe, '/nachricht/hmm[@name="BerichtseinheitID"]/wert', 'BERICHTSEINHEIT_ID') + return ausgabe + + def schreibeSegmentkopf(self, ausgabe, content, ): + ausgabe = fcts.setMerkmal(ausgabe, '/nachricht/datensegment/meldungsID', 'MELDUNGS_ID') + return ausgabe + + def schreibeSegmentsatz(self, ausgabe, content, index): + for feld in Person.FELDER: + ausgabe = fcts.setMerkmalContent(ausgabe, content, index, feld) + return ausgabe + + +class Absender(): + FELDER = ("ABSENDER_KENNUNG", "ABSENDER_IDENTITÄT", "ABSENDER_TELEFON", "ABSENDER_EMAIL", "ABSENDER_FAX", "ABSENDER_URL", "BERICHTSEINHEIT_ID", "REGNAME") + + def __init__(self): + content = reader.readCsv("testdaten/allgemein/absender.csv", "keys") + self.keys = content["tabelle"]["absender"]["_keys"] + +class Vrfelder(): + def __init__(self): + with open(r'src/config/vrFelder.yml') as file: + content = yaml.full_load(file) + self.conf = content + + def getVrfeld(self, feld): + print("gerVrfeld "+feld) + if feld in self.conf["config"]: + print("gerVrfeld treffer"+feld) + return self.conf["config"][feld] + pass + +class Anschrift(): + FELDER = ("GEMSCHL", "HNR", "HNR_BUCHST", "HNR_TEILNR", "HNR_UNST", "ORTSTEIL", "ORTSTEIL_POST", "PLZ", "STOCKNR_WHG", "STR", "STRSCHL", "WOHNORT", "ZUSATZ") + +class Person(): + FELDER = ("IDNR", "DR", "FAMNAME", "FAMNAME_AE", "FAMNAME_BEST", "FAMNAME_ZUS", "FAMNAME_VOR", "FAMNAME_UNST", "GEB_DAT", "GEBNAME", "GEBNAME_BEST1", "GEBNAME_BEST2", "GEBNAME_UNST", "GEBSTAAT", "GEB_ORT", "GESCHLECHT", "STAATSANG", "VORNAME", "VORNAME_AE") + +""" +Werkzeuge, um Register-Merkmale zu erstellen, setzen, ... +""" +class fcts: + #+MULTI_NODE = ("mm", "hmm", "omm", "erhebung") + MULTI_NODE = ("erhebung") + #+ARRAY_NODE = ("satz", "ressource") + ARRAY_NODE = ("mm", "hmm", "omm", "satz", "ressource") + + def isLastGroup(pfad, knoten): + if (pfad[(pfad.find(knoten)+len(knoten)+4):].find("[@") > 1): + return False + return True + + def getNodename(knotenname): + if ("[@" in knotenname): + return knotenname[0:knotenname.find("[@")] + return knotenname + + def getKeyname(knotenname): + if ("[@" in knotenname): + return knotenname[knotenname.find("[@")+1:knotenname.find("=")] + return knotenname + + def setArrayElem(array, elem): + # sets or appends the element/key-val into the array + for k in array: + if (elem in array): + return array + array.append(elem) + + def addMerkmal(baum, pfad, index, wert): + """ + Eingabe: + baum inklusive Elternknoten + pfad kompletter Pfad von Wurzel bis Blatt + index auf den Pfad + wert einzutragender Wert + Verarbeitung + basis der zu bearbeitende Knotenname extrahiert von Attributen + elem zu bearbeitender Knoten + zu betrachtende Fälle: + a: basis intendiert ein Array: + b: basis intendiert ein Dictionary: + c: basis ist ein einfacher Knoten + Weiter zu betrachten hinsichtlich Komplexität des Knotens + .a einfacher Knoten + .b Knoten mit Attribut als Blatt (anode+bnode) oder mit Unterknoten (nur anode) + Weiter zu betrachten hinsichtlich Pfadposition + ..a: Blatt - Wert eintragen und + ..b: im Pfad - weiterer rekursiver Aufruf + Ausgabe: + baum inklusive Elternknoten + """ + logdebug = 3 # Schalter zur Debug-Einstellung innerhalb der Funktion + if logdebug >= 1: print("--- addMerkmal "+str(index)+" "+pfad+" "+wert) + if logdebug >= 3: print("--- addMerkmal "+str(baum)) + + # # # # # # # # # # # # # # # # # # # # + # basis der zu bearbeitende Knotenname extrahiert von Attributen + # elem zu bearbeitender Knoten + elem = {} + a = pfad.strip('/').split('/') + anode = None # optional fuer Attribute + bnode = None # optional fuer direkte Wertzuordnung #text + basis = "" # Knotenname - ohne Attribute + + if ("[@" in a[index]): + if logdebug >= 1: print("0b") + basis = a[index][0:a[index].find("[@")] + attribs = a[index][a[index].find("[@")+1:a[index].find("]")] + aname = attribs[0:attribs.find("=")] + aval = attribs[attribs.find("=")+2:-1] + if logdebug >= 3 : print("0b "+basis+" : "+aname+" = "+aval) + aarr = [aname , aval] + anode = {} + anode[aname] = aval + if (index == len(a)-1): + barr = ["#text", wert] + bnode = {} + bnode["#text"] = wert + if logdebug >= 3 : print("0b "+basis+" "+str(anode)+" "+str(bnode)) + else: + basis = a[index] + if logdebug >= 3 : print("0b "+basis+" "+str(anode)+" "+str(bnode)) + if (basis in baum): + elem[basis] = baum[basis] + nindex = index+1 + if logdebug >= 1: print("1 "+a[index]+" "+wert+" "+str(baum)) + + # # # # # # # # # # # # # # # # # # # # + # zu betrachtende Fälle: + # a: basis intendiert ein Array: + # b: basis intendiert ein Dictionary: + # c: basis ist ein einfacher Knoten + # Weiter zu betrachten hinsichtlich Komplexität des Knotens + # .a einfacher Knoten + # .b Knoten mit Attribut als Blatt (anode+bnode) oder mit Unterknoten (nur anode) + # Weiter zu betrachten hinsichtlich Pfadposition + # ..a: Blatt - Wert eintragen und + # ..b: im Pfad - weiterer rekursiver Aufruf + # + # # # Fall a : Array + if (basis in fcts.ARRAY_NODE): + # Weiter zu betrachten + # .a einfacher Knoten + # .b Knoten mit Attribut als Blatt (anode+bnode) oder mit Unterknoten (nur anode) + # Weiter zu betrachten hinsichtlich Pfadposition + # ..a: Blatt - Wert eintragen und + # ...a zusaetzliches Blatt + # ...b ueberschriebenes Blatt OPEN + # ..b: im Pfad - weiterer rekursiver Aufruf + # ...a expandierter Pfad + # ...b fortgefuehrter Pfad + existKnoten = "N" + hatAttr = "N" + istWert = "N" + hatWert = "N" + expand = "N" + lastidx = 0 + if logdebug >= 1: print("a: ARRAY "+a[index-1]+"-"+basis+" "+str(baum)) + if (basis in baum): + # ggf. zu bearbeitendes ELEM erzeugen + if (isinstance(baum[basis], dict)): + print ("200 dict vorhanden") + if (len(baum[basis].keys()) <1): + elem[basis] = [] + elem[basis].append({}) + if (isinstance(baum[basis], list)): + print ("201 array vorhanden "+str(baum[basis])) + #if baum[basis] + existKnoten = "J" + elem[basis] = baum[basis] + else: + print ("203 neues array") + elem[basis] = [] + elem[basis].append({}) + existKnoten = "N" + xnode = {} + if (anode): + hatAttr = "J" + xnode = {} # Komplexitaetsfaelle in xnode setzen + if logdebug >= 3: print("a-b "+basis+" "+str(anode)) + ##elem[basis].append(anode) + #if (not aarr[0] in elem[basis]): #+ + # if logdebug >= 3: print("a-b "+basis+" anode ergaenzt "+str(anode)) + # #-elem[basis].append(anode) + xnode = anode + if (bnode): # a-b-a + istWert = "J" + if logdebug >= 3: print("existKnoten "+existKnoten+" hatAttr "+hatAttr+" istWert "+istWert+" hatWert "+ hatWert+" expand "+expand+" lastidx "+str(lastidx)) + if logdebug >= 3: print("-->a-b-a-b> kompl. Blatt "+basis+" "+str(bnode)) + #-elem[basis].append(bnode) + elem[basis][0][aarr[0]] = aarr[1] + elem[basis][0][barr[0]] = barr[1] + baum[basis] = elem[basis] + if logdebug >= 3: print("<--a-b-a-b< kompl. Blatt "+basis+" "+str(elem)) + return baum + # weitere Fallunterscheidung: unterster Komplexknoten erweitern, vorherige durchlaufen + subnode = fcts.getNodename(a[nindex]) + parentkey = fcts.getKeyname(a[index-1]) + realnode = subnode + aridx = -1 + if (basis in elem): + for x in elem[basis]: + print("x: "+str(x)+" "+str(len(x.keys()))) + if len(x.keys()) > 0: + print ("x ist") + aridx += 1 + # aridx -= 1 + lastidx = aridx + print ("## Faluntersuchung parentkey "+parentkey+" aridx "+str(aridx)+" subnode "+subnode) + if ((aridx < 0)): # a-b-b-a + elem[basis][0][realnode] = {} + elem[basis][0][realnode][aarr[0]] = aarr[1] + if logdebug >= 3: print("existKnoten "+existKnoten+" hatAttr "+hatAttr+" istWert "+istWert+" hatWert "+ hatWert+" expand "+expand+" lastidx "+str(lastidx)) + if logdebug >= 3: print("-->a-b-b-a> kompl. Pfad init " +basis+" "+parentkey+" " + realnode + " " + wert +" "+str(nindex)+" "+str(baum)) + insnode = fcts.addMerkmal(elem[basis][0][realnode], pfad, nindex, wert) + if logdebug >= 3: print("<--a-b-b-a< kompl. Pfad init " + basis+" "+str(insnode)+"-set-0-"+str(elem[basis][0])) + elem[basis][0] = insnode + baum[basis] = elem[basis] + return baum ## + if fcts.isLastGroup(pfad, basis): # a-b-b-a expandierter Pfad + subnode = fcts.getNodename(a[nindex]) + if logdebug >= 3: print("existKnoten "+existKnoten+" hatAttr "+hatAttr+" istWert "+istWert+" hatWert "+ hatWert+" expand "+expand+" lastidx "+str(lastidx)) + if logdebug >= 3: print("-->a-b-b-a> kompl. Pfaderw "+subnode+" "+str(nindex)+" "+str(anode)+" "+str(baum)) + insnode = fcts.addMerkmal(anode, pfad, nindex, wert) + if logdebug >= 3: print("<--a-b-b-a< kompl. Pfaderw. " + basis + " "+str(insnode)+"-ins-"+str(elem[basis][0])) + elem[basis].append(insnode) + baum[basis] = elem[basis] + return baum + else: + # hier soll in dem Knoten weiternavigiert werden + # satz[@klasse="1"]/mm[@name="2"]... + # basis = satz, subnode = mm + # baum = {satz: [{ @klasse : 1, mm : [{ @name : 0, .. + subnode = fcts.getNodename(a[nindex]) + realnode = subnode + if "[@" in subnode: + realnode = a[nindex+1] + if logdebug >= 3: + print (basis) + print (elem) + print (baum) + aridx = 0 + if (basis in baum): + aridx = len(baum[basis])-1 + #if (aridx >= 0) and (): + # elem[basis] = [] + # elem[basis].append(anode) + # .b Knoten mit Attribut als Blatt (anode+bnode) oder mit Unterknoten (nur anode) + # Weiter zu betrachten hinsichtlich Pfadposition + # ..a: Blatt - Wert eintragen und #-DONE-# + # ...a zusaetzliches Blatt #-OPEN-# + # ...b ueberschriebenes Blatt #-DONE-# + # ..b: im Pfad - weiterer rekursiver Aufruf + # ...a initialer Pfadposition #-DONE-# + # ...b expandierter Pfad + # ...c fortgefuehrter Pfad + if (aridx > 0 and logdebug >= 3): + print (basis+" ++ "+str(aridx)+" "+subnode) + print(str(baum[basis])) + print(str(baum[basis][aridx])) + if ((aridx > 0) and (realnode in baum[basis][aridx].keys())): + elem[basis] = [] + #elem[basis].append(elem[basis][aridx][realnode]) + if logdebug >= 3: print("existKnoten "+existKnoten+" hatAttr "+hatAttr+" istWert "+istWert+" hatWert "+ hatWert+" expand "+expand+" lastidx "+str(lastidx)) + if logdebug >= 3: print("-->a-b-b-c> kompl. Pfad " +basis+" "+ realnode + " " + wert + " " + str(nindex) + " " + str(aridx)+" "+str(baum)) + insnode = fcts.addMerkmal(elem[basis][aridx], pfad, nindex, wert)[realnode] + if logdebug >= 3: print("<--a-b-b-c< kompl. Pfad " + basis+" "+str(insnode)+"-set-"+str(elem[basis][aridx][realnode])) + elem[basis][aridx][realnode] = insnode + else: + #elem[basis] = [] + #elem[basis].append(anode) + if logdebug >= 3: print("existKnoten "+existKnoten+" hatAttr "+hatAttr+" istWert "+istWert+" hatWert "+ hatWert+" expand "+expand+" lastidx "+str(lastidx)) + if logdebug >= 3: print("-->a-b-b-b> kompl. Pfad " +basis+" "+ realnode + " " + wert + " " + str(nindex) + " " + str(aridx)+" "+str(baum)) + insnode = fcts.addMerkmal(elem[basis][lastidx], pfad, nindex, wert) + if logdebug >= 3: print("<--a-b-b-b< kompl. Pfad " + basis+" "+str(insnode)+"-set-"+str(elem[basis][aridx])) + #elem[basis].append(insnode) + pass + baum[basis] = elem[basis] + return baum + # unerreichbar, da schon im else returned + #if logdebug >= 3: + # print("-->a-b-b> kompl. Pfad "+basis+" "+str(nindex)) + # print("-->a-b-b> kompl. Pfad "+realnode+" "+str(nindex)+" "+str(baum)) + # print("-->a-b-b> kompl. Pfad "+realnode+" "+str(nindex)+" "+str(elem)) + #if not subnode in elem[basis][0]: + # elem[basis][0][realnode] = {} + # elem[basis][0][realnode][aarr[0]] = aarr[1] + # elem[basis][0] = fcts.addMerkmal(elem[basis][0][realnode], pfad, nindex, wert) + #elif (len(elem[basis]) > 0): + # elem[basis].append(fcts.addMerkmal(xnode, pfad, nindex, wert)) + #+elem[basis].append(fcts.addMerkmal(xnode, pfad, nindex, wert)) + #if logdebug >= 3: + # print (basis) + # print(baum) + # print(elem) + # print("<--a-b-b< kompl. Pfad "+basis+""+str(baum)) + #baum[basis] = elem[basis] + #return baum ## + else: + if logdebug >= 3: print("-->a-a-b> einf. Pfad "+str(nindex)+" "+str(baum)) + return baum + ##### Fall 3ab ## Dict + elif (basis in fcts.MULTI_NODE): + if logdebug >= 1: print("b: DICT "+basis) + if (not basis in baum): + print ("elem angelegt") + elem[basis] = {} + if (anode ): + if logdebug >= 3: print("b-b "+basis+" "+str(anode)) + elem[basis][aarr[0]] = aarr[1] + if (bnode): + elem[basis][barr[0]] = barr[1] + baum[basis] = elem[basis] + #elem[basis].append(bnode) + if logdebug >= 3: print("<<--b-b-a< kompl. Blatt "+basis+" "+str(index)+" "+str(elem)) + return baum + if ("[@" in a[index+1]): + subbasis = a[index+1][0:a[index+1].find("[@")] + if logdebug >= 3: print("-->b-b-b> kompl. Pfad "+basis+" "+str(index)+" "+str(elem)) + elem[basis] = fcts.addMerkmal(elem[basis], pfad, nindex, wert) + baum[basis] = elem[basis] + if logdebug >= 3: print("<--b-b-b< kompl. Pfad "+basis+" "+str(index)+" "+str(baum)) + return baum + else: + subbasis = a[index+1] + if logdebug >= 3: print("-->b-a-b> einf. Pfad "+basis+" "+str(index)+" "+str(elem)) + elem[basis][subbasis] = fcts.addMerkmal({}, pfad, nindex, wert) + baum[basis] = elem[basis] + if logdebug >= 3: print("<--b-a-b< einf. Pfad "+basis+" "+str(index)+" "+str(elem)) + return baum + # baum[basis] = elem[basis] + return baum[basis] + ###### Fall einfach + vorhanden + else: + if (basis in baum): + elem[basis] = baum[basis] + else: + elem[basis] = {} + if logdebug >= 1: print("c: EINFACH "+a[index-1]+"-"+basis+" "+str(baum)) + if (1 == len(a)-index): + if logdebug >= 3 : print("3b "+basis+" "+str(anode)+" "+str(bnode)) + if (anode): + elem[basis] = {} + elem[basis][aarr[0]] = aarr[1] + if logdebug >= 3 : print("3b1") + if (bnode): + elem[basis][barr[0]] = barr[1] + baum[basis] = elem[basis] + if logdebug >= 3 : print("<<-- c-b-a kompl. Blatt "+basis+" "+str(baum)) + return baum + elem[basis] = {} + elem[basis] = wert + baum[basis] = elem[basis] + if logdebug >= 3 : print("<<-- c-a-a einf. Blatt "+basis+" "+str(anode)+" "+str(baum)) + return baum + if (anode): + if logdebug >= 3: print("-->c-b-b> kompl. Pfad "+basis+" "+nindex) + elem[basis] = fcts.addMerkmal(elem[basis], pfad, nindex, wert) + baum[basis] = elem[basis] + if logdebug >= 3: print("<--c-b-b< kompl. Pfad "+basis+" "+nindex+" "+str(baum)) + return baum[basis][basis] ## + if logdebug >= 3: print("-->c-a-b> einf. Pfad "+basis) + baum[basis] = fcts.addMerkmal(elem[basis], pfad, nindex, wert) + if logdebug >= 3: print("<--c-a-b< einf. Pfad "+basis+" "+str(index)+" "+str(baum)) + return baum + + # ----------------------------------------- + def setMerkmal(baum, pfad, wert): + logdebug = 3 # Schalter zur Debug-Einstellung innerhalb der Funktion + if logdebug >= 1: print("----------------------------------------- setMerkmal ---------------------") + if logdebug >= 1: print("setMerkmal "+pfad+" "+wert) + #MULTI_NODE = ("mm", "hmm", "omm", "ressource") + elem = baum + if logdebug >= 2 : print ("setMerkmal "+pfad+" "+wert) + a = pfad.strip('/').split('/') + if ("[@" in a[0]): + basis = a[0][0:a[0].find("[@")] + else: + basis = a[0] + if (1 == len(a)): + baum[basis] = wert + return baum + if (basis in baum): + elem = baum[basis] + else: + elem = {} + # for i in range(0, len(a)): + if logdebug >= 1: print("setMerkmal "+basis+" "+str(elem)) + baum = fcts.addMerkmal(baum, pfad, 0, wert) + if logdebug >= 1: print("setMerkmal "+basis+" "+str(baum)) + if True: + return baum + if (1 == len(a)): + elem[a[0]] = wert + for i in range(0, len(a)): + if logdebug >= 3 : print("for "+str(i)+" "+a[i]) + if ("[@" in a[i]): + basis = a[i][0:a[i].find("[@")] + else: + basis = a[i] + print ("basis "+basis ) + #if (a[i] in elem): + if ((not basis in fcts.MULTI_NODE) and (basis in elem)): + if logdebug >= 3 : print("a "+basis) + elem = elem[basis] + else: + if ("[@" in a[i]): + if logdebug >= 3 : print("b "+a[i]) + node = a[i][0:a[i].find("[@")] + attribs = a[i][a[i].find("[@")+1:a[i].find("]")] + aname = attribs[0:attribs.find("=")] + aval = attribs[attribs.find("=")+2:-1] + if logdebug >= 3 : print("b "+node+" : "+aname+" = "+aval) + + if (node in elem): + if logdebug >= 3 : print("b "+node+" in elem ") + #if logdebug >= 3 : print(json.dumps(elem[node])) + if ("dict" in str(type(elem[node]))): + if logdebug >= 3 : print(node +" elem[node] ist dict") + xnode = elem[node] + elem[node] = [] + elem[node].append(xnode) + else: + if logdebug >= 3 : print(node+" elem[node] ist nicht dict"+str(type(elem[node]))) + pnode = {} + pnode[aname] = aval + print (str(i)+" ?= "+str(len(a))) + if (i == len(a)-1): + pnode["#text"] = wert + elem[node].append(pnode) + else: + elem[node] = {} + elem = elem[node] + elem[aname] = aval + if (i == len(a)-1): + elem["#text"] = wert + elif (i == len(a)-1): + if logdebug >= 3 : print("c "+a[i]) + elem[a[i]] = wert + else: + if logdebug >= 3 : print("d "+a[i]) + elem[str(a[i])] = {} + elem = elem[str(a[i])] + return baum + + def setMerkmalContent(baum, content, index, feld): + logdebug = 1 # Schalter zur Debug-Einstellung innerhalb der Funktion + if logdebug >= 1 : print ("setMerkmalContent "+feld+" "+content["absender"]["REGNAME"]) + vrfeld = content["vrfelder"].getVrfeld(feld) + if logdebug >= 2 : print(type(vrfeld)) + if logdebug >= 2 : print(json.dumps(vrfeld)) + tabelle = "#" + + + #print (type(vrfeld)+" "+str(vrfeld)) + if (("tabelle" in vrfeld.keys()) and (vrfeld["tabelle"] == "absender")): + if logdebug >= 2 : print ("absender") + pass + elif (not "Register" in vrfeld): + if logdebug >= 2 : print ("kein Register") + return baum + elif (vrfeld["Register"].find(content["absender"]["REGNAME"])<0): + if logdebug >= 2 : print("verboten ") + return baum + if (not ("tabelle" in vrfeld.keys())): + if logdebug >= 2 : print ("keine tabelle") + return baum + elif (vrfeld["tabelle"][0:1] == "#"): + if logdebug >= 2 : print ("# tabelle") + return baum + xpath = vrfeld["Xpath"] + tabelle = vrfeld["tabelle"] + if logdebug >= 3 : print ("args "+tabelle+" "+xpath) + # pfadkennung ersetzen + if (xpath.find('${')>0): + ersatz = xpath[xpath.find('${')+2:xpath.find('}')] + npath = xpath[0:xpath.find('${')]+content["absender"][ersatz]+xpath[xpath.find('}')+1:] + else: + npath = xpath + if logdebug >= 2 : print ("npath "+npath) + npath = npath.replace('nachricht/', '') + if logdebug >= 2 : print ("npath "+npath) + if (tabelle == "absender"): + baum = fcts.setMerkmal(baum, npath, content["absender"][feld]) + return baum + # Wert ermitteln aus Content + if logdebug >= 3 : print (str(index) +" tabelle "+str(content)) + if (not content["tabelle"][tabelle]["_data"][int(index)-1]): + if logdebug >= 2 : print ("Zeile fehlt") + return baum + if logdebug >= 3 : print (content["tabelle"][tabelle]["_data"][int(index)-1]) + if (not feld in content["tabelle"][tabelle]["_data"][int(index)-1].keys()): + if logdebug >= 2 : print ("Feld fehlt") + return baum + wert = content["tabelle"][tabelle]["_data"][int(index)-1][feld] + baum = fcts.setMerkmal(baum, npath, wert) + #print("ausgabe "+str(baum)) + return baum + + def test(): + print("test in fcts") + +class merkmal: + def __init__(self): + self.merkmale = "loadyaml" \ No newline at end of file