|
|
|
@ -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" |
Ulrich Carmesin