10 changed files with 715 additions and 10 deletions
@ -0,0 +1,197 @@ |
|||||
|
#!/usr/bin/python |
||||
|
# -*- coding: utf-8 -*- |
||||
|
# --------------------------------------------------------------------------------------------------------- |
||||
|
# Author : Ulrich Carmesin |
||||
|
# Source : gitea.ucarmesin.de |
||||
|
# --------------------------------------------------------------------------------------------------------- |
||||
|
import unittest |
||||
|
import inspect |
||||
|
import os |
||||
|
import json |
||||
|
import basic.program |
||||
|
import utils.path_tool |
||||
|
import utils.path_const as P |
||||
|
import utils.config_tool |
||||
|
import utils.data_const as D |
||||
|
import basic.toolHandling |
||||
|
import test.constants |
||||
|
import basic.component |
||||
|
import basic.constants as B |
||||
|
import utils.map_tool |
||||
|
import utils.file_tool |
||||
|
import test.testtools |
||||
|
import utils.tdata_tool |
||||
|
|
||||
|
HOME_PATH = test.constants.HOME_PATH |
||||
|
|
||||
|
conf = {} |
||||
|
# here you can select single testfunction for developping the tests |
||||
|
# "test_toolhandling", "test_parseSql" -> test of components |
||||
|
TEST_FUNCTIONS = ["test_02getIds", "test_03extractIds", "test_04getFieldVal", "test_05getValue", |
||||
|
"test_11mapTdata"] |
||||
|
TEST_FUNCTIONS = ["test_11mapTdata"] |
||||
|
verbose = False |
||||
|
|
||||
|
class MyTestCase(unittest.TestCase): |
||||
|
mymsg = "--------------------------------------------------------------" |
||||
|
|
||||
|
def test_03extractIds(self): |
||||
|
global mymsg |
||||
|
actfunction = str(inspect.currentframe().f_code.co_name) |
||||
|
cnttest = 0 |
||||
|
if actfunction not in TEST_FUNCTIONS: |
||||
|
return |
||||
|
job = test.testtools.getJob() |
||||
|
res = utils.map_tool.extractIds(job, "1") |
||||
|
self.assertEqual(res, ["1"]) |
||||
|
res = utils.map_tool.extractIds(job, "1, 2") |
||||
|
self.assertEqual(res, "1,2".split(",")) |
||||
|
res = utils.map_tool.extractIds(job, "1-3") |
||||
|
self.assertEqual(res, "1,2,3".split(",")) |
||||
|
res = utils.map_tool.extractIds(job, "1, 3-6, 8") |
||||
|
self.assertEqual(res, "1,3,4,5,6,8".split(",")) |
||||
|
cnttest += 4 |
||||
|
MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest) |
||||
|
|
||||
|
|
||||
|
def test_02getIds(self): |
||||
|
global mymsg |
||||
|
actfunction = str(inspect.currentframe().f_code.co_name) |
||||
|
cnttest = 0 |
||||
|
if actfunction not in TEST_FUNCTIONS: |
||||
|
return |
||||
|
job = test.testtools.getJob() |
||||
|
path = utils.config_tool.getConfigPath(P.KEY_TESTCASE, "TC0001", "", job) |
||||
|
tdata = utils.tdata_tool.getCsvSpec(job.m, path, D.CSV_SPECTYPE_DATA) |
||||
|
args = {} |
||||
|
args[B.DATA_NODE_DATA] = tdata |
||||
|
args[B.DATA_NODE_STEPS] = tdata[B.DATA_NODE_STEPS][0] |
||||
|
args[utils.map_tool.ACT_ID] = {} |
||||
|
args[utils.map_tool.ID_LIST] = {} |
||||
|
ids = {} |
||||
|
res = utils.map_tool.getIds(job, args, "msgid={_steps._nr}") |
||||
|
print(res) |
||||
|
self.assertEqual(res[0], "1") |
||||
|
self.assertIn("msgid", args[utils.map_tool.ID_LIST]) |
||||
|
cnttest += 1 |
||||
|
res = utils.map_tool.getIds(job, args, "sender={_data.person._sender(_steps._nr)}") |
||||
|
print(res) |
||||
|
self.assertEqual(res[0], "firma") |
||||
|
args[B.DATA_NODE_STEPS] = tdata[B.DATA_NODE_STEPS][1] |
||||
|
res = utils.map_tool.getIds(job, args, "msgid={_steps._nr}") |
||||
|
self.assertEqual(res[1], "2") |
||||
|
self.assertIn("msgid", args[utils.map_tool.ID_LIST]) |
||||
|
cnttest += 1 |
||||
|
args[utils.map_tool.ACT_ID]["msgid"] = "1" |
||||
|
res = utils.map_tool.getIds(job, args, "posid={_data.product._nr,_pos(msgid)}") |
||||
|
self.assertEqual(res[0], ("1", "4")) |
||||
|
self.assertEqual(res[1], ("1", "5")) |
||||
|
cnttest += 1 |
||||
|
compName = "testcrmdb" |
||||
|
args[B.DATA_NODE_COMP] = test.testtools.getComp(compName) |
||||
|
comp = args[B.DATA_NODE_COMP] |
||||
|
conf = utils.config_tool.getConfig(D.DDL_FILENAME, compName, "person") |
||||
|
comp.conf[B.DATA_NODE_DDL] = {} |
||||
|
comp.conf[B.DATA_NODE_DDL]["person"] = conf |
||||
|
res = utils.map_tool.getIds(job, args, "fields={_comp.ddl.person}") |
||||
|
print(res) |
||||
|
args[utils.map_tool.ACT_ID]["posid"] = ("1", "4") |
||||
|
res = utils.map_tool.getConditions(job, args, "{posid}") |
||||
|
print(res) |
||||
|
self.assertEqual(res[0], ("1", "4")) |
||||
|
#self.assertEqual(res[1], "4") |
||||
|
cnttest += 1 |
||||
|
MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest) |
||||
|
|
||||
|
|
||||
|
def test_04getFieldVal(self): |
||||
|
global mymsg |
||||
|
actfunction = str(inspect.currentframe().f_code.co_name) |
||||
|
cnttest = 0 |
||||
|
if actfunction not in TEST_FUNCTIONS: |
||||
|
return |
||||
|
job = test.testtools.getJob() |
||||
|
path = utils.config_tool.getConfigPath(P.KEY_TESTCASE, "TC0001", "", job) |
||||
|
tdata = utils.tdata_tool.getCsvSpec(job.m, path, D.CSV_SPECTYPE_DATA) |
||||
|
condIds = [["1"]] |
||||
|
args = {} |
||||
|
args[B.DATA_NODE_DATA] = tdata |
||||
|
res = utils.map_tool.getFieldVal(job, args, "person", "_sender", condIds) |
||||
|
print(res) |
||||
|
condIds = [["1"], ["4"]] |
||||
|
res = utils.map_tool.getFieldVal(job, args, "product", "descript", condIds) |
||||
|
print(res) |
||||
|
|
||||
|
def test_05getValue(self): |
||||
|
global mymsg |
||||
|
actfunction = str(inspect.currentframe().f_code.co_name) |
||||
|
cnttest = 0 |
||||
|
if actfunction not in TEST_FUNCTIONS: |
||||
|
return |
||||
|
job = test.testtools.getJob() |
||||
|
path = utils.config_tool.getConfigPath(P.KEY_TESTCASE, "TC0001", "", job) |
||||
|
tdata = utils.tdata_tool.getCsvSpec(job.m, path, D.CSV_SPECTYPE_DATA) |
||||
|
condIds = [["1"]] |
||||
|
args = {} |
||||
|
args[B.DATA_NODE_DATA] = tdata |
||||
|
args[B.DATA_NODE_STEPS] = tdata[B.DATA_NODE_STEPS][0] |
||||
|
args[utils.map_tool.ACT_ID] = {} |
||||
|
args[utils.map_tool.ID_LIST] = {} |
||||
|
#res = utils.map_tool.getValue(job, args, "msgid={_steps._nr}") |
||||
|
#-print(res) |
||||
|
#self.assertEqual(res, ['1']) |
||||
|
args[utils.map_tool.ACT_ID]["msgid"] = ['1'] |
||||
|
#res = utils.map_tool.getValue(job, args, "sender={_data.person._sender(msgid)}") |
||||
|
#self.assertEqual(res, ["firma"]) |
||||
|
#print(res) |
||||
|
print(args[utils.map_tool.ID_LIST]) |
||||
|
args[utils.map_tool.ACT_ID]["sender"] = "firma" |
||||
|
res = utils.map_tool.getValue(job, args, "{_catalog.sender.depart(sender)}") |
||||
|
self.assertEqual(res, "main") |
||||
|
res = utils.map_tool.getValue(job, args, "{_steps.args.action}") |
||||
|
print(res) |
||||
|
res = utils.map_tool.getValue(job, args, "{_par.tctime}") |
||||
|
print(res) |
||||
|
args[utils.map_tool.ACT_ID]["msgid"] = "1" |
||||
|
res = utils.map_tool.getValue(job, args, "{_data.person.famname(msgid)}") |
||||
|
print(res) |
||||
|
self.assertEqual(res, "Brecht") |
||||
|
args[utils.map_tool.ACT_ID]["msgid"] = "1" |
||||
|
# select row if field is missing |
||||
|
res = utils.map_tool.getValue(job, args, "{_data.person(msgid)}") |
||||
|
print(res) |
||||
|
res = utils.map_tool.getValue(job, args, "hier ist ein Text") |
||||
|
print(res) |
||||
|
# it is one row [{f_1: v_2, ...}] |
||||
|
|
||||
|
|
||||
|
def test_11mapTdata(self): |
||||
|
global mymsg |
||||
|
actfunction = str(inspect.currentframe().f_code.co_name) |
||||
|
cnttest = 0 |
||||
|
if actfunction not in TEST_FUNCTIONS: |
||||
|
return |
||||
|
job = test.testtools.getJob() |
||||
|
comp = test.testtools.getComp("testrest") |
||||
|
path = os.path.join(job.conf.confs[B.SUBJECT_PATH][B.ATTR_PATH_COMPS], "testrest", "mapping-rest.yml") |
||||
|
mapping = utils.file_tool.readFileDict(path, job.m) |
||||
|
path = utils.config_tool.getConfigPath(P.KEY_TESTCASE, "TC0001", "", job) |
||||
|
tdata = utils.tdata_tool.getCsvSpec(job.m, path, D.CSV_SPECTYPE_DATA) |
||||
|
res = utils.map_tool.mapTdata(job, mapping, tdata, tdata[B.DATA_NODE_STEPS][1], comp) |
||||
|
print(res) |
||||
|
for format in ["xml", "yml", "json"]: |
||||
|
path = os.path.join(job.conf.confs[B.SUBJECT_PATH][B.ATTR_PATH_TDATA], "temp", "result-rest."+format) |
||||
|
print(path) |
||||
|
utils.file_tool.writeFileDict(job.m, path, res) |
||||
|
doc = json.dumps(res, indent=0) |
||||
|
print(doc) |
||||
|
MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest) |
||||
|
|
||||
|
|
||||
|
def test_zzz(self): |
||||
|
print(MyTestCase.mymsg) |
||||
|
|
||||
|
|
||||
|
if __name__ == '__main__': |
||||
|
verbose = True |
||||
|
unittest.main() |
||||
@ -0,0 +1,59 @@ |
|||||
|
#!/usr/bin/python |
||||
|
# -*- coding: utf-8 -*- |
||||
|
# --------------------------------------------------------------------------------------------------------- |
||||
|
# Author : Ulrich Carmesin |
||||
|
# Source : gitea.ucarmesin.de |
||||
|
# --------------------------------------------------------------------------------------------------------- |
||||
|
import unittest |
||||
|
import inspect |
||||
|
import os |
||||
|
import basic.program |
||||
|
import utils.path_tool |
||||
|
import utils.path_const as P |
||||
|
import utils.config_tool |
||||
|
import utils.data_const as D |
||||
|
import basic.toolHandling |
||||
|
import test.constants |
||||
|
import basic.component |
||||
|
import basic.constants as B |
||||
|
import utils.file_abstract |
||||
|
import utils.file_tool |
||||
|
import test.testtools |
||||
|
import utils.tdata_tool |
||||
|
|
||||
|
HOME_PATH = test.constants.HOME_PATH |
||||
|
|
||||
|
conf = {} |
||||
|
# here you can select single testfunction for developping the tests |
||||
|
# "test_toolhandling", "test_parseSql" -> test of components |
||||
|
TEST_FUNCTIONS = ["test_11mapTdata"] |
||||
|
TEST_FUNCTIONS = ["test_05getValue"] |
||||
|
verbose = False |
||||
|
|
||||
|
class MyTestCase(unittest.TestCase): |
||||
|
mymsg = "--------------------------------------------------------------" |
||||
|
|
||||
|
|
||||
|
def test_11mapTdata(self): |
||||
|
global mymsg |
||||
|
actfunction = str(inspect.currentframe().f_code.co_name) |
||||
|
cnttest = 0 |
||||
|
if actfunction not in TEST_FUNCTIONS: |
||||
|
return |
||||
|
job = test.testtools.getJob() |
||||
|
comp = test.testtools.getComp("testrest") |
||||
|
path = os.path.join(job.conf.confs[B.SUBJECT_PATH][B.ATTR_PATH_COMPS], "testrest", "mapping-rest.yml") |
||||
|
mapping = utils.file_tool.readFileDict(path, job.m) |
||||
|
path = utils.config_tool.getConfigPath(P.KEY_TESTCASE, "TC0001", "", job) |
||||
|
tdata = utils.tdata_tool.getCsvSpec(job.m, path, D.CSV_SPECTYPE_DATA) |
||||
|
res = utils.file_abstract.mapTdata(job, mapping, tdata, tdata[B.DATA_NODE_STEPS][0], comp) |
||||
|
MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest) |
||||
|
|
||||
|
|
||||
|
def test_zzz(self): |
||||
|
print(MyTestCase.mymsg) |
||||
|
|
||||
|
|
||||
|
if __name__ == '__main__': |
||||
|
verbose = True |
||||
|
unittest.main() |
||||
@ -0,0 +1,375 @@ |
|||||
|
#!/usr/bin/python |
||||
|
# -*- coding: utf-8 -*- |
||||
|
# --------------------------------------------------------------------------------------------------------- |
||||
|
# Author : Ulrich Carmesin |
||||
|
# Source : gitea.ucarmesin.de |
||||
|
# --------------------------------------------------------------------------------------------------------- |
||||
|
import os |
||||
|
import re |
||||
|
import basic.program |
||||
|
import basic.catalog |
||||
|
import utils.config_tool |
||||
|
import basic.constants as B |
||||
|
import basic.toolHandling |
||||
|
import utils.data_const as D |
||||
|
import utils.file_tool |
||||
|
import utils.path_tool |
||||
|
import basic.catalog |
||||
|
|
||||
|
ACT_ID = "actid" |
||||
|
ID_LIST = "idlist" |
||||
|
MAP_ID = "_id" |
||||
|
MAP_FOR = "_foreach" |
||||
|
MAP_ROW = "_row" |
||||
|
MAP_FCTS = [ MAP_FOR, MAP_ID, MAP_ROW ] |
||||
|
MODUL_NAME = "map_tool" |
||||
|
|
||||
|
|
||||
|
def mapTdata(job, mapping, tdata, step, comp): |
||||
|
""" |
||||
|
initialize the mapping from testdata into the mapping-structure |
||||
|
:param job: |
||||
|
:param mapping: |
||||
|
:param tdata: |
||||
|
:param step: |
||||
|
:param comp: |
||||
|
:return: |
||||
|
""" |
||||
|
verify = job.getDebugLevel(MODUL_NAME) |
||||
|
out = {} |
||||
|
path = "" |
||||
|
job.debug(verify, mapping) |
||||
|
args = {} |
||||
|
args[B.DATA_NODE_COMP] = comp |
||||
|
args[B.DATA_NODE_DATA] = tdata |
||||
|
args[B.DATA_NODE_STEPS] = step |
||||
|
args[ACT_ID] = {} |
||||
|
args[ID_LIST] = {} |
||||
|
out = mapElement(job, args, mapping, path, out) |
||||
|
job.debug(verify, ">>>>>>>>>>> \n"+str(out)) |
||||
|
return out |
||||
|
|
||||
|
|
||||
|
def mapElement(job, args, elem, path, out): |
||||
|
""" |
||||
|
recursive mapping with building the dict of the testdata |
||||
|
:param job: |
||||
|
:param args: |
||||
|
:param elem: |
||||
|
:param path: |
||||
|
:param out: |
||||
|
:return: |
||||
|
""" |
||||
|
verify = job.getDebugLevel(MODUL_NAME) |
||||
|
job.debug(verify, "mapElem "+path+" id: "+str(args[ACT_ID])) |
||||
|
if isinstance(elem, dict): |
||||
|
job.debug(verify, "##### dict ") |
||||
|
nodes = [] |
||||
|
attrNodes = [] |
||||
|
leafNodes = [] |
||||
|
objNodes = [] |
||||
|
for k in elem: |
||||
|
if MAP_ID in elem[k] or MAP_FOR in elem[k]: |
||||
|
objNodes.append(k) |
||||
|
elif k[0:1] == '@' or k[0:1] == '#': |
||||
|
attrNodes.append(k) |
||||
|
else: |
||||
|
leafNodes.append(k) |
||||
|
job.debug(verify, "nodes "+str(attrNodes)+" - "+str(leafNodes)+" - "+str(objNodes)) |
||||
|
nodes = attrNodes + leafNodes + objNodes |
||||
|
for k in nodes: |
||||
|
# iterating this elem is declared inside of the elem |
||||
|
# like foreach but only one element |
||||
|
job.debug(verify, "# # "+k) |
||||
|
if MAP_ID in elem[k] or MAP_FOR in elem[k]: |
||||
|
job.debug(verify, "# + k in obj : val "+k) |
||||
|
if MAP_ID in elem[k]: |
||||
|
key = elem[k][MAP_ID][0:elem[k][MAP_ID].find("=")] |
||||
|
idlist = getIds(job, args, elem[k][MAP_ID]) |
||||
|
if len(idlist) > 1: |
||||
|
uniqueKeys = {} |
||||
|
for x in idlist: |
||||
|
uniqueKeys[x] = x |
||||
|
if len(uniqueKeys) > 1: |
||||
|
raise Exception("bei keyword _id there is only one element allowed "+str(idlist)) |
||||
|
else: |
||||
|
idlist = uniqueKeys.keys() |
||||
|
elif MAP_FOR in elem[k]: |
||||
|
key = elem[k][MAP_FOR][0:elem[k][MAP_FOR].find("=")] |
||||
|
idlist = getIds(job, args, elem[k][MAP_FOR]) |
||||
|
sublist = [] |
||||
|
a = path.split(",") |
||||
|
a.append(k) |
||||
|
npath = ",".join(a) |
||||
|
for id in idlist: |
||||
|
args[ACT_ID][key] = str(id) |
||||
|
if MAP_ROW in elem[k]: |
||||
|
row = getRow(job, args, elem[k][MAP_ROW]) |
||||
|
sublist.append(mapElement(job, args, elem[k], npath, {})) |
||||
|
out[k] = sublist |
||||
|
elif k == MAP_ID or k == MAP_FOR or k == MAP_ROW: |
||||
|
job.debug(verify, "# + k in MAP : continue "+k) |
||||
|
continue |
||||
|
else: |
||||
|
job.debug(verify, "# + k in leaf : val "+k) |
||||
|
a = path.split(",") |
||||
|
a.append(k) |
||||
|
npath = ",".join(a) |
||||
|
job.debug(verify, "mapElem - dict "+k) |
||||
|
out[k] = mapElement(job, args, elem[k], npath, {}) |
||||
|
elif isinstance(elem, list): |
||||
|
out = [] |
||||
|
i = 0 |
||||
|
for k in elem: |
||||
|
job.debug(verify, "mapElem - list "+str(k)) |
||||
|
a = path.split(",") |
||||
|
a.append(str(i)) |
||||
|
npath = ",".join(a) |
||||
|
out.append(mapElement(job, args, elem[i], path, {})) |
||||
|
i += 1 |
||||
|
else: |
||||
|
job.debug(verify, "mapElem - leaf " + elem) |
||||
|
|
||||
|
if elem[0:1] == "{" and elem[-1:] == "}": |
||||
|
elem = elem[1:-1] |
||||
|
out = toSimpleType(job, getValue(job, args, elem)) |
||||
|
return out |
||||
|
|
||||
|
|
||||
|
def toSimpleType(job, value): |
||||
|
if isinstance(value, (list, tuple)) and len(value) == 1: |
||||
|
return value[0] |
||||
|
return value |
||||
|
|
||||
|
def extractIds(job, idval): |
||||
|
ids = [] |
||||
|
if isinstance(idval, list) or isinstance(idval, tuple): |
||||
|
a = idval |
||||
|
else: |
||||
|
a = idval.split(",") |
||||
|
for k in a: |
||||
|
if "-" in k: |
||||
|
b = k.split("-") |
||||
|
for i in range(int(b[0].strip()), int(b[1].strip())+1): |
||||
|
ids.append(str(i).strip()) |
||||
|
elif isinstance(k, str): |
||||
|
ids.append(k.strip()) |
||||
|
else: |
||||
|
ids.append(k) |
||||
|
return ids |
||||
|
|
||||
|
|
||||
|
def getRow(job, args, fieldkey): |
||||
|
a = fieldkey.split(".") |
||||
|
row = getValue(job, args, fieldkey) |
||||
|
if B.DATA_NODE_ROW not in args: args[B.DATA_NODE_ROW] = {} |
||||
|
a[1] = a[1][0:a[1].find("(")] |
||||
|
args[B.DATA_NODE_ROW][a[1]] = row[0] |
||||
|
return row |
||||
|
|
||||
|
def getIds(job, args, fieldkey): |
||||
|
""" |
||||
|
sets the id resp list of ids into args[idlist] |
||||
|
the fieldkey has a formula like id={_source.table.field(condition)} |
||||
|
:param job: |
||||
|
:param args: |
||||
|
:param fieldky: |
||||
|
:return: |
||||
|
""" |
||||
|
verify = job.getDebugLevel(MODUL_NAME) |
||||
|
job.debug(verify, "match = "+fieldkey) |
||||
|
out = [] |
||||
|
idfield = fieldkey |
||||
|
if re.match(r"(.+)\=(.+)", fieldkey): |
||||
|
res = re.search(r"(.+)\=(.+)", fieldkey) |
||||
|
idfield = res.group(1) |
||||
|
fieldkey = res.group(2) |
||||
|
if fieldkey[0:1] == "{" and fieldkey[-1:] == "}": |
||||
|
fieldkey = fieldkey[1:-1] |
||||
|
if "temp" not in args: args["temp"] = {} |
||||
|
i = 0 |
||||
|
while "(" in fieldkey and ")" in fieldkey: |
||||
|
innerCond = fieldkey[fieldkey.rfind("(")+1:fieldkey.find(")")] |
||||
|
if "." not in innerCond: |
||||
|
break |
||||
|
innerkey = "temp_"+str(i) |
||||
|
args["temp"][innerkey] = {} |
||||
|
args["temp"][innerkey]["idfield"] = idfield |
||||
|
args["temp"][innerkey]["fieldkey"] = fieldkey |
||||
|
innerlist = getIds(job, args, innerkey+"={"+innerCond+"}") |
||||
|
args[ACT_ID][innerkey] = ",".join(innerlist) |
||||
|
fieldkey = fieldkey.replace(innerCond, innerkey) |
||||
|
idfield = args["temp"][innerkey]["idfield"] |
||||
|
i += 1 |
||||
|
if i > 3: |
||||
|
raise Exception("too much searches "+str(args["temp"])) |
||||
|
val = getValue(job, args, fieldkey) |
||||
|
idlist = extractIds(job, val) |
||||
|
args[ID_LIST][idfield] = idlist |
||||
|
job.debug(verify, "idlist " + str(args[ID_LIST])) |
||||
|
return idlist |
||||
|
|
||||
|
|
||||
|
def getConditions(job, args, fieldkey): |
||||
|
""" |
||||
|
gets a list of condition-value |
||||
|
:param job: |
||||
|
:param args: |
||||
|
:param fieldkey: in formula (c_1, c_2, ..) |
||||
|
:return: [v_1} ..] |
||||
|
""" |
||||
|
verify = job.getDebugLevel(MODUL_NAME) |
||||
|
while fieldkey[0:1] == "(" and fieldkey[-1:] == ")": |
||||
|
fieldkey = fieldkey[1:-1] |
||||
|
while fieldkey[0:1] == "{" and fieldkey[-1:] == "}": |
||||
|
fieldkey = fieldkey[1:-1] |
||||
|
out = [] |
||||
|
a = fieldkey.split(",") |
||||
|
if len(a) > 1: |
||||
|
job.m.logError("map-condition should not have more parts - use tupel "+fieldkey) |
||||
|
for k in a: |
||||
|
if "." in k: |
||||
|
raise Exception("Formatfehler in " + fieldkey) |
||||
|
job.debug(verify, "actid " + str(args[ACT_ID])) |
||||
|
idelem = {} |
||||
|
idelem[k] = args[ACT_ID][k] |
||||
|
out.append(args[ACT_ID][k]) |
||||
|
return out |
||||
|
|
||||
|
|
||||
|
def getValue(job, args, fieldkey): |
||||
|
""" |
||||
|
gets the value of the formula like {_source.table.field(condition)} |
||||
|
:param job: |
||||
|
:param args: |
||||
|
:param fieldkey: |
||||
|
:return: |
||||
|
""" |
||||
|
verify = job.getDebugLevel(MODUL_NAME) |
||||
|
job.debug(verify, "getValue "+fieldkey) |
||||
|
while fieldkey[0:1] == "{" and fieldkey[-1:] == "}": |
||||
|
fieldkey = fieldkey[1:-1] |
||||
|
val = "" |
||||
|
idfield = "" |
||||
|
source = "" |
||||
|
table = "" |
||||
|
field = "" |
||||
|
cond = "" |
||||
|
condIds = [] |
||||
|
# special cases of id-management |
||||
|
# args[actid][xid] = actual id with name xid |
||||
|
# args[idlist][xid] = list of all ids with name xid |
||||
|
# a) declaration of the id : id={fielddefinition} |
||||
|
if re.match(r".+\=.+", fieldkey): |
||||
|
job.debug(verify, "getValue 222 " + fieldkey) |
||||
|
raise Exception("getIds sollte an passender Stelle direkt aufgerufen werden "+fieldkey) |
||||
|
return getIds(job, args, fieldkey) |
||||
|
# b) set of defined ids - neither fielddefinition nor a function |
||||
|
#elif "." not in fieldkey and "(" not in fieldkey or re.match(r"\(.+\)", fieldkey): |
||||
|
#print("getValue 226 " + fieldkey) |
||||
|
#raise Exception("getConditions sollte an passender Stelle direkt aufgerufen werden") |
||||
|
#return getConditions(job, args, fieldkey) |
||||
|
# fielddefinition with .-separated parts |
||||
|
b = fieldkey.split(".") |
||||
|
job.debug(verify, "match field "+fieldkey) |
||||
|
if re.match(r"(_.+)\..+\..+\(.+\)", fieldkey): |
||||
|
res = re.match(r"(_.+)\.(.+)\.(.+\(.+\))", fieldkey) |
||||
|
job.debug(verify, "match mit ()") |
||||
|
source = res.group(1) |
||||
|
table = res.group(2) |
||||
|
field = res.group(3) |
||||
|
#cond = res.group(4) |
||||
|
#condIds = getValue(job, args, cond) |
||||
|
elif len(b) == 1: |
||||
|
field = b[0] |
||||
|
elif len(b) == 2: |
||||
|
source = b[0] |
||||
|
field = b[1] |
||||
|
elif len(b) == 3: |
||||
|
source = b[0] |
||||
|
table = b[1] |
||||
|
field = b[2] |
||||
|
if re.match(r".+\(.+\)", field): |
||||
|
res = re.match(r"(.+)\((.+)\)", field) |
||||
|
field = res.group(1) |
||||
|
cond = res.group(2) |
||||
|
condIds = getConditions(job, args, cond) |
||||
|
job.debug(verify, source + " - " + table + " - " + field + " - " + cond + " : " + str(condIds)) |
||||
|
if source == B.DATA_NODE_ROW: |
||||
|
if table not in args[B.DATA_NODE_ROW]: |
||||
|
raise Exception("row not initialiazed for table "+table+" "+str(args[B.DATA_NODE_ROW])) |
||||
|
row = args[B.DATA_NODE_ROW][table] |
||||
|
val = row[field] |
||||
|
elif source == B.DATA_NODE_DATA: |
||||
|
job.debug(verify, "data " + b[1]) |
||||
|
if len(b) == 3: |
||||
|
job.debug(verify, table + ", " + field + ", " + cond + ", " + str(condIds)) |
||||
|
val = toSimpleType(job, getFieldVal(job, args, table, field, condIds)) |
||||
|
elif len(b) == 2: |
||||
|
job.debug(verify, table + ", " + field + ", " + cond + ", " + str(condIds)) |
||||
|
val = getTdataRow(job, args[B.DATA_NODE_DATA], field, condIds) |
||||
|
elif source == B.DATA_NODE_STEPS: |
||||
|
job.debug(verify, "steps " + table+" - "+ field) |
||||
|
if hasattr(args[B.DATA_NODE_STEPS], field): |
||||
|
val = getattr(args[B.DATA_NODE_STEPS], field) |
||||
|
elif hasattr(args[B.DATA_NODE_STEPS], table): |
||||
|
row = getattr(args[B.DATA_NODE_STEPS], table) |
||||
|
if field in row: |
||||
|
val = row[field] |
||||
|
elif source[1:] == B.DATA_NODE_PAR: |
||||
|
job.debug(verify, "par " + b[1]) |
||||
|
if getattr(job.par, b[1]): |
||||
|
val = getattr(job.par, b[1]) |
||||
|
elif source == B.DATA_NODE_CATALOG: |
||||
|
job.debug(verify, "catalog " + table+", "+ field) |
||||
|
if len(b) != 3: |
||||
|
job.debug(verify, "catalog-Fehler") |
||||
|
return "Fehler-145" |
||||
|
row = basic.catalog.Catalog.getInstance().getValue(table, args[ACT_ID][cond], job) |
||||
|
if isinstance(row, dict) and field in row: |
||||
|
val = row[field] |
||||
|
elif source[1:] == B.DATA_NODE_COMP: |
||||
|
job.debug(verify, "comp "+table+", "+field) |
||||
|
comp = args[B.DATA_NODE_COMP] |
||||
|
if table == B.DATA_NODE_DDL: |
||||
|
fields = comp.conf[B.DATA_NODE_DDL][field][B.DATA_NODE_HEADER] |
||||
|
val = ",".join(fields) |
||||
|
else: |
||||
|
val = fieldkey |
||||
|
job.debug(verify, "return val "+str(val)) |
||||
|
return val |
||||
|
|
||||
|
def getFieldVal(job, args, table, field, condIds): |
||||
|
out = [] |
||||
|
fields = field.split(",") |
||||
|
for row in getTdataRow(job, args[B.DATA_NODE_DATA], table, condIds): |
||||
|
if len(fields) == 1 and field in row: |
||||
|
out.append( str(row[field]).strip()) |
||||
|
else: |
||||
|
tup = tuple() |
||||
|
for f in fields: |
||||
|
if f in row: |
||||
|
t = tuple( str(row[f]).strip() ) |
||||
|
tup = tup + t |
||||
|
else: |
||||
|
raise Exception("field is missing in row "+f+", "+str(row)) |
||||
|
out.append(tup) |
||||
|
return out |
||||
|
|
||||
|
def getTdataRow(job, tdata, table, condIds): |
||||
|
verify = job.getDebugLevel(MODUL_NAME) |
||||
|
out = [] |
||||
|
idFields = {} |
||||
|
job.debug(verify, "getTdata "+str(condIds)) |
||||
|
for i in range(0, len(condIds)): |
||||
|
idFields[tdata[B.DATA_NODE_TABLES][table][B.DATA_NODE_HEADER][i]] = condIds[i] |
||||
|
job.debug(verify, "idFields "+str(idFields)) |
||||
|
for row in tdata[B.DATA_NODE_TABLES][table][B.DATA_NODE_DATA]: |
||||
|
i = 0 |
||||
|
for k in idFields: |
||||
|
for j in range(0, len(idFields[k])): |
||||
|
if row[k] == idFields[k][j]: |
||||
|
i += 1 |
||||
|
if i == len(idFields): |
||||
|
out.append(row) |
||||
|
return out |
||||
Loading…
Reference in new issue