60 changed files with 653 additions and 1310 deletions
@ -0,0 +1,5 @@ |
|||
#!/usr/bin/python |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
# Author : Ulrich Carmesin |
|||
# Source : gitea.ucarmesin.de |
|||
# --------------------------------------------------------------------------------------------------------- |
|||
@ -1,757 +0,0 @@ |
|||
#import dpath.util |
|||
import json |
|||
import yaml |
|||
import re |
|||
import datetime |
|||
import utils.tdata_tool |
|||
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"][B.DATA_NODE_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 = utils.tdata_tool.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 getTidyTab(self, depth=0): |
|||
tab = "" |
|||
# print("depth "+str(depth)) |
|||
for i in range(0, depth): |
|||
tab += "\t" |
|||
return tab |
|||
|
|||
def hasTidyAttr(self, tree): |
|||
first = True |
|||
if isinstance(tree, dict): |
|||
for x in tree: |
|||
if first and isinstance(tree[x], dict): |
|||
return self.hasTidyAttr(tree[x]) |
|||
elif first and isinstance(tree[x], list): |
|||
return self.hasTidyAttr(tree[x]) |
|||
elif x[0:1] == "@": |
|||
return True |
|||
else: |
|||
return False |
|||
if isinstance(tree, list): |
|||
for x in tree: |
|||
if first and isinstance(x, dict): |
|||
return self.hasTidyAttr(x) |
|||
elif first and isinstance(x, list): |
|||
return self.hasTidyAttr(x) |
|||
elif x[0:1] == "@": |
|||
return True |
|||
else: |
|||
return False |
|||
elif tree[0:1] == "@": |
|||
return True |
|||
return False |
|||
|
|||
def getTidyAttr(self, tree, x, depth=0): |
|||
xml = "" |
|||
attr = "" |
|||
if isinstance(tree, dict): |
|||
for y in tree: |
|||
if isinstance(y, dict): |
|||
return "" |
|||
elif isinstance(y, list): |
|||
attr = self.getTidyAttr(y, x, depth) |
|||
elif y[0:1] == "@": |
|||
attr += " "+y[1:]+"="+tree[y] |
|||
elif len(attr) > 1: |
|||
xml = "<"+x+attr+">"+y+"</"+x+">" |
|||
return xml |
|||
else: |
|||
return "" |
|||
elif isinstance(tree, dict): |
|||
for y in tree: |
|||
pass |
|||
return "" |
|||
|
|||
def getTidyDict(self, tree, x, depth=0): |
|||
xml = "" |
|||
tab = self.getTidyTab(depth) |
|||
newTree = {} |
|||
attr = "" |
|||
for y in tree: |
|||
if y[0:1] == "@": |
|||
attr = " " + y[1:] + "=\"" + tree[y] + "\"" |
|||
else: |
|||
newTree[y] = tree[y] |
|||
if len(newTree) > 0: |
|||
xml += tab + "<" + x + attr + ">\n" + self.tidy(newTree, depth + 1) + tab + "</" + x + ">\n" |
|||
else: |
|||
xml += tab + "<" + x + attr + "/>\n" |
|||
return xml |
|||
|
|||
def tidy(self, tree, depth=0): |
|||
verify = 0 |
|||
xml = "" |
|||
tab = self.getTidyTab(depth) |
|||
hasa = self.hasTidyAttr(tree) |
|||
if verify: print("getTidy "+str(type(tree))+" hasAttr "+str(hasa)) |
|||
if isinstance(tree, dict): |
|||
for x in tree: |
|||
if verify: print("dict " + str(x)) |
|||
if isinstance(tree[x], dict): |
|||
hasa = self.hasTidyAttr(tree[x]) |
|||
newTree = {} |
|||
attr = "" |
|||
for y in tree[x]: |
|||
if verify: print("y-for "+str(y)) |
|||
if y[0:1] == "@": |
|||
attr = " " + y[1:] + "=\"" + tree[x][y] + "\"" |
|||
else: |
|||
newTree[y] = tree[x][y] |
|||
if len(newTree) > 0: |
|||
xml += tab + "<" + x + attr + ">\n" + self.tidy(newTree, depth + 1) + tab + "</" + x + ">\n" |
|||
else: |
|||
xml += tab + "<" + x + attr + "/>\n" |
|||
elif isinstance(tree[x], list): |
|||
hasa = self.hasTidyAttr(tree[x]) |
|||
if hasa: |
|||
xml += tab + "<" + x + self.tidy(tree[x], depth) + "</" + x + ">\n" |
|||
else: |
|||
xml += tab + "<" + x + ">\n" + self.tidy(tree[x], depth + 1) + tab + "</" + x + ">\n" |
|||
elif x[0:1] == "@": |
|||
attr = " " + x[1:] + "=\"" + tree[x] + "\"" |
|||
elif x == "#text": |
|||
xml = str(tree[x]) |
|||
return xml |
|||
else: |
|||
xml += tab + "<" + x + ">" + str(tree[x]) + "</" + x + ">\n" |
|||
elif isinstance(tree, list): |
|||
for x in tree: |
|||
if verify: print("list " + str(x)) |
|||
if isinstance(x, dict): |
|||
newTree = {} |
|||
attr = "" |
|||
text = False |
|||
hasa = self.hasTidyAttr(x) |
|||
for y in x: |
|||
if verify: print("y-for "+str(y)) |
|||
if y[0:1] == "@": |
|||
attr = " " + y[1:] + "=\"" + x[y] + "\"" |
|||
elif y == "#text": |
|||
text = x[y] |
|||
else: |
|||
newTree[y] = x[y] |
|||
if text and len(newTree) > 0 and len(attr) > 0: |
|||
xml += "" + attr + ">" + self.tidy(newTree, depth + 1) |
|||
elif len(newTree) > 0 and len(attr) > 0: |
|||
xml += "" + attr + ">\n" + self.tidy(newTree, depth + 1) + tab |
|||
elif len(attr) > 0: |
|||
if not isinstance(x, dict): |
|||
xml += tab + "<296" + x + attr + "/>\n" |
|||
else: |
|||
xml += attr + ">"+text |
|||
else: |
|||
xml += self.tidy(newTree, depth) |
|||
else: |
|||
xml += tab + "<" + x + ">\n" + self.tidy(x, depth) + tab + "</" + x + ">" |
|||
else: |
|||
xml += "<" + str(tree) + ">" |
|||
return xml |
|||
|
|||
|
|||
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][B.DATA_NODE_DATA][int(index)-1]): |
|||
if logdebug >= 2 : print ("Zeile fehlt") |
|||
return baum |
|||
if logdebug >= 3 : print (content["tabelle"][tabelle][B.DATA_NODE_DATA][int(index)-1]) |
|||
if (not feld in content["tabelle"][tabelle][B.DATA_NODE_DATA][int(index)-1].keys()): |
|||
if logdebug >= 2 : print ("Feld fehlt") |
|||
return baum |
|||
wert = content["tabelle"][tabelle][B.DATA_NODE_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" |
|||
Loading…
Reference in new issue