def __initConnDict(self):
newConnDict = {}
for conn in self.connDict:
dictProp = {}
dictProp[eConn.props.NAME] = conn
dictProp[eConn.props.TYPE] = conn
if isinstance(self.connDict[conn], dict):
for k in self.connDict[conn]:
origK = findEnum(prop=k, obj=eConn.props)
if origK:
dictProp[origK] = self.connDict[conn][k]
elif k.lower() in newConnDict:
dictProp[k.lower()] = self.connDict[conn][k]
else:
dictProp[k] = self.connDict[conn][k]
elif isinstance(self.connDict[conn], str):
dictProp[eConn.props.URL] = self.connDict[conn]
newConnDict[conn] = dictProp
### VALID CONNECTION TYPES
errConn = []
for conn in newConnDict:
if not findEnum(prop=newConnDict[conn][eConn.props.TYPE],
obj=eConn.types):
p(
"Remove Connection %s becouse prop: %s is NOT VALID !!"
%
(str(conn), str(newConnDict[conn][eConn.props.TYPE])),
"e")
errConn.append(conn)
for err in errConn:
del newConnDict[err]
self.connDict = newConnDict
def __init__(self, propertyDict=None, **args):
""" ABSTRACT METHOD THAT MUST BE IMPLEMETED IN ANY CHILD CLASSES """
baseConn.__init__(self, propertyDict=propertyDict, **args)
self.dataTypes = self.setDataTypes(connDataTypes=setProperty(
k=eConn.props.DATA_TYPES, o=args, defVal={}))
self.connType = setProperty(k=eConn.props.TYPE, o=self.propertyDict)
self.connName = setProperty(k=eConn.props.NAME,
o=self.propertyDict,
defVal=self.connType)
self.connIsSrc = setProperty(k=eConn.props.IS_SOURCE,
o=self.propertyDict,
defVal=False)
self.connIsTar = setProperty(k=eConn.props.IS_TARGET,
o=self.propertyDict,
defVal=False)
self.connIsSql = setProperty(k=eConn.props.IS_SQL,
o=self.propertyDict,
defVal=False)
self.connFilter = setProperty(k=eConn.props.FILTER,
o=self.propertyDict,
defVal=None)
self.connUpdateMethod = setProperty(k=eConn.props.UPDATE,
o=self.propertyDict)
self.isSingleObject = True
if not findEnum(prop=self.connType, obj=eConn.types):
err = "{}: Connection NOT VALID !!".format(self.connType)
raise ValueError(err)
def __setUpdate(self, val):
if str(val).isdigit():
if findEnum(prop=val, obj=eConn.updateMethod):
return val
else:
p("THERE IS %s WHICH IS MAPPED TO UPDATE PROPERTY, MUST HAVE -1(drop), 1(UPDATE), 2(NO_UPDATE), USING -1 DROP--> CREATE METHOD "
)
return -1
def __notVaildProp(self, currentPropDic, enumPropertyClass):
ret = {}
for k in currentPropDic:
prop = findEnum(prop=k, obj=enumPropertyClass)
if not prop:
p(
"%s: NOT VALID. LEGAL VALUES: %s -> ignore" %
(k, str(getAllProp(enumPropertyClass))), "e")
ret[prop] = currentPropDic[k]
return ret
def __sourceOrTargetOrQueryConn(self, propFullName, propVal):
ret = {}
if isinstance(propVal, str):
ret[eConn.props.NAME] = propFullName
ret[eConn.props.TYPE] = propFullName
ret[eConn.props.TBL] = propVal
elif isinstance(propVal, list):
ret[eConn.props.NAME] = propFullName
ret[eConn.props.TYPE] = propFullName
if len(propVal) == 1:
ret[eConn.props.TYPE] = propFullName
ret[eConn.props.TBL] = propVal[0]
elif len(propVal) == 2:
ret[eConn.props.TYPE] = propVal[0]
ret[eConn.props.TBL] = propVal[1]
elif len(propVal) == 3:
ret[eConn.props.TYPE] = propVal[0]
ret[eConn.props.TBL] = propVal[1]
if self.__isDigitStr(propVal[2]):
ret[eConn.props.UPDATE] = self.__setUpdate(propVal[2])
else:
ret[eConn.props.FILTER] = propVal[2]
elif len(propVal) == 4:
ret[eConn.props.TYPE] = propVal[0]
ret[eConn.props.TBL] = propVal[1]
ret[eConn.props.FILTER] = propVal[2]
ret[eConn.props.UPDATE] = self.__setUpdate(propVal[3])
else:
p(
"%s: Not valid list valuues, must 1,2 or 3 VALUE IS: \n %s"
% (str(propFullName), str(propVal)), "e")
elif isinstance(propVal, dict):
ret = self.__notVaildProp(currentPropDic=propVal,
enumPropertyClass=eConn.props)
if eConn.props.NAME not in ret and eConn.props.TYPE in ret:
ret[eConn.props.NAME] = ret[eConn.props.TYPE]
if eConn.props.TYPE not in ret and eConn.props.NAME in ret:
ret[eConn.props.TYPE] = ret[eConn.props.NAME]
else:
p("Not valid values: %s " % (propVal), "e")
return {}
if findEnum(prop=ret[eConn.props.NAME], obj=eJson) == eJson.QUERY:
ret[eConn.props.IS_SQL] = True
return ret
def __index(self, propVal):
## propVal = [{col:[],'iu':True, 'ic':True},{}]
if isinstance(propVal, (dict, OrderedDict)):
propVal = [propVal]
if not isinstance(propVal, list):
p("INDEX VALUES MUST BE A DICTIONARY OR LIST OF DICTIOANRY, FORMAT {'C'':list_column_index, 'ic':is cluster (True/False), 'iu': is unique (True/False)}"
)
return
ret = []
for indexDict in propVal:
if not isinstance(indexDict, (dict, OrderedDict)):
p("INDEX MUST BE DICTIOANY, FORMAT {'C'':list_column_index, 'ic':is cluster (True/False), 'iu': is unique (True/False)}"
)
continue
returnDict = {
eConn.props.DB_INDEX_COLUMS: [],
eConn.props.DB_INDEX_CLUSTER: True,
eConn.props.DB_INDEX_UNIQUE: False
}
for node in indexDict:
k = findEnum(prop=node.lower(), obj=eJson.index)
if not k:
p("INDEX VALUES IS NOT VALID: %s, IGNORE INDEX. VALID FORMAT: FORMAT {'C'':list_column_index, 'ic':is cluster (True/False), 'iu': is unique (True/False)}"
)
break
if k == eConn.props.DB_INDEX_COLUMS:
if isinstance(indexDict[node], list):
returnDict[eConn.props.DB_INDEX_COLUMS].extend(
indexDict[node])
else:
returnDict[eConn.props.DB_INDEX_COLUMS].append(
indexDict[node])
elif k == eConn.props.DB_INDEX_CLUSTER:
if not indexDict[node]:
returnDict[eConn.props.DB_INDEX_CLUSTER] = False
elif k == eConn.props.DB_INDEX_UNIQUE:
if indexDict[node]:
returnDict[eConn.props.DB_INDEX_UNIQUE] = True
else:
p(
"INDEX - UNRECOGNIZED KEY %s IN DICT:%s IGNORE. VALID FORMAT: FORMAT {'C'':list_column_index, 'ic':is cluster (True/False), 'iu': is unique (True/False)}"
% (str(node), str(indexDict)), "e")
ret.append(indexDict)
return ret
def __initMetaDict(self, listObj, destList=None):
for node in listObj:
if isinstance(node, list):
self.__initMetaDict(listObj=node, destList=destList)
elif isinstance(node, dict):
stt = OrderedDict()
newDict = OrderedDict()
for prop in node:
k = findEnum(prop=prop, obj=eJson)
if k:
if eJson.SOURCE in newDict and k == eJson.QUERY:
p("Source and Query exists - Will use Query", "ii")
del newDict[eJson.SOURCE]
elif eJson.QUERY in newDict and k == eJson.SOURCE:
p("Query and Source exists - Will use Source",
"ii")
del newDict[eJson.QUERY]
if k == eJson.STT or k == eJson.STTONLY:
newSttL = OrderedDict([x.lower(), x]
for x in node[prop])
sttL = {x.lower(): x for x in stt}
for s in stt:
if s.lower() in newSttL:
stt[s].update(
node[prop][newSttL[s.lower()]])
for s in newSttL:
if s not in sttL:
stt[newSttL[s]] = node[prop][newSttL[s]]
newDict[k] = stt
# parse source / target / query
elif k == eJson.SOURCE or k == eJson.TARGET or k == eJson.QUERY:
newDict[k] = self.__sourceOrTargetOrQueryConn(
propFullName=prop, propVal=node[prop])
# parse merge
elif k == eJson.MERGE:
newDict[k] = self.__mergeConn(existsNodes=newDict,
propFullName=prop,
propVal=node[prop])
# parse column data types
elif k == eJson.COLUMNS:
stt = self.__sttAddColumns(stt=stt,
propVal=node[prop])
newDict[eJson.STTONLY] = stt
if eJson.STT in newDict:
del newDict[eJson.STT]
# parse column mapping
elif k == eJson.MAP:
stt = self.__sttAddMappings(stt=stt,
propVal=node[prop])
if eJson.STT in newDict:
newDict[eJson.STT] = stt
else:
newDict[eJson.STTONLY] = stt
elif k == eJson.INDEX:
index = self.__index(propVal=node[prop])
if index:
newDict[eJson.INDEX] = index
elif k == eJson.CREATE:
newDict[k] = self.__createFrom(propVal=node[prop])
else:
p("%s not implemented !" % (k), "e")
else:
newDict[prop.lower()] = self.__uniqueProc(
propVal=node[prop])
self.jsonMapp.append(newDict)
else:
p("jsonParser->__initMetaDict: Unknown node prop values: %s " %
node)