def __parseArgs(self, params, meta):
upperParams = {}
for p in params.keys():
pCap = p[0].upper() + p[1:]
upperParams[pCap] = params[p]
# CHECK FOR EVIL !!
if 'information_schema' in meta['table']:
return upperParams
if self.SCHEMA.has_key(meta['table']):
_columns = self.SCHEMA[meta['table']]['columns']
if len(upperParams) != len(_columns):
msg = 'Arguments length is %d, got %d - %s'
msg = msg % (len(_columns), len(upperParams), str(upperParams))
raise RSSDBException(msg)
for _col in _columns:
if not upperParams.has_key(_col):
raise RSSDBException('Wrong parameter name: %s' % _col)
return upperParams
def __parseKwargs(self, meta):
pKwargs = {}
for ak in self.ACCEPTED_KWARGS:
pKwargs[ak] = meta.pop(ak, None)
if not pKwargs.has_key('table') or pKwargs['table'] is None:
raise RSSDBException('Table name not given')
if 'information_schema' in pKwargs['table']:
return pKwargs
if not self.SCHEMA.has_key(pKwargs['table']):
raise RSSDBException('Table "%s" not found' % pKwargs['table'])
if pKwargs['uniqueKeys'] is None:
pKwargs['uniqueKeys'] = self.SCHEMA[pKwargs['table']]['keyColumns']
return pKwargs
def parseMultiple(l):
if parsedKwargs[l] is None:
return None
if not isinstance(parsedKwargs[l], list):
parsedKwargs[l] = [parsedKwargs[l]]
res = self.dbWrapper.db._escapeValues(parsedKwargs[l])
#res = self._checkMultipleALPHA( parsedKwargs[ l ] )
if not res['OK']:
raise RSSDBException(res['Message'])
return res['Value']
def _checkFLOAT(self, suspicious):
for i in suspicious:
if type(i) not in (int, float, long):
raise RSSDBException('Non numeric value "%s"' % suspicious)
return suspicious
def _checkDATETIME(self, suspicious):
for s in suspicious:
if not isinstance(s, datetime):
raise RSSDBException('Non datetime value "%s"' % s)
return ['"%s"' % s.replace(microsecond=0) for s in suspicious]
def _checkVARCHAR(self, suspicious):
res = self.dbWrapper.db._escapeValues(suspicious)
if not res['OK']:
raise RSSDBException(res['Message'])
return res['Value']
def _checkALPHA(self, suspicious):
if not re.match("[A-Za-z_-]+$", suspicious):
raise RSSDBException('Non alpha value "%s"' % suspicious)
return suspicious
def __parseEvil(self, parsedArgs, parsedKwargs):
#First parameters, then meta
if self.mSchema is None:
for k, v in parsedArgs.items():
if not isinstance(v, list):
v = [v]
parsedArgs[k] = self._checkVARCHAR(v)
return parsedArgs, parsedKwargs
#parsedMeta
def parseMultiple(l):
if parsedKwargs[l] is None:
return None
if not isinstance(parsedKwargs[l], list):
parsedKwargs[l] = [parsedKwargs[l]]
res = self.dbWrapper.db._escapeValues(parsedKwargs[l])
#res = self._checkMultipleALPHA( parsedKwargs[ l ] )
if not res['OK']:
raise RSSDBException(res['Message'])
return res['Value']
def parseDict2(mm, table, d):
if d is None:
return d
res = []
for k, v in d.items():
k = self._checkALPHA(k)
# get type for check
dataType = getattr(table, k).dataType.upper()
if not isinstance(v, list):
v = [v]
v = getattr(self, '_check%s' % dataType)(v)
res.append((k, v))
return dict(res)
# table alreadyChecked
table = getattr(self.mSchema, parsedKwargs['table'])
# sort
if parsedKwargs.has_key('sort') and parsedKwargs['sort'] is not None:
parsedKwargs['sort'] = self._checkMultipleALPHA(
parsedKwargs['sort']) #parseMultiple( 'sort' )
# order
if parsedKwargs.has_key('order') and parsedKwargs['order'] is not None:
parsedKwargs['order'] = self._checkMultipleALPHA(
parsedKwargs['order']) #parseMultiple( 'order' )
# limit
if parsedKwargs.has_key('limit') and parsedKwargs['limit'] is not None:
if not isinstance(parsedKwargs['limit'], int):
raise RSSDBException('Non integer limit value')
# columns
if parsedKwargs.has_key(
'columns') and parsedKwargs['columns'] is not None:
parsedKwargs['columns'] = self._checkMultipleALPHA(
parsedKwargs['columns']) #parseMultiple( 'columns' )
# group
if parsedKwargs.has_key('group') and parsedKwargs['group'] is not None:
parsedKwargs['group'] = self._checkMultipleALPHA(
parsedKwargs['group'])[0] #parseMultiple( 'group' )
# uniqueKeys
if parsedKwargs.has_key(
'uniqueKeys') and parsedKwargs['uniqueKeys'] is not None:
parsedKwargs['uniqueKeys'] = self._checkMultipleALPHA(
parsedKwargs['uniqueKeys']) #parseMultiple( 'uniqueKeys' )
# count
if parsedKwargs.has_key('count') and parsedKwargs[
'count'] is not None and parsedKwargs['count'] != True:
#count = self.dbWrapper.db._escapeString( parsedKwargs[ 'count' ])
count = self._checkALPHA(parsedKwargs['count'])
if not count['OK']:
raise RSSDBException('Cannot escape count value')
parsedKwargs['count'] = count['Value']
# or
if parsedKwargs.has_key('or') and parsedKwargs['or'] is not None:
orD = parsedKwargs['or']
if orD is not None:
parsedOr = []
for d in orD:
#small hack to prevent a crash parsing the arguments of the dict
d['kwargs']['table'] = parsedKwargs['table']
pDict, pKw = self.__parseEvil(d['dict'], d['kwargs'])
parsedOr.append({'dict': pDict, 'kwargs': pKw})
#orD[ 'dict' ],orD[ 'kwargs' ] = self.__parseEvil( orD[ 'dict' ],orD[ 'kwargs' ] )
parsedKwargs['or'] = parsedOr
# minor ( datetime )
if parsedKwargs.has_key('minor') and parsedKwargs['minor'] is not None:
parsedKwargs['minor'] = parseDict2(self, table,
parsedKwargs['minor'])
# not ( string )
if parsedKwargs.has_key('not') and parsedKwargs['not'] is not None:
parsedKwargs['not'] = parseDict2(self, table, parsedKwargs['not'])
# parsedArgs
for k, v in parsedArgs.items():
self._checkALPHA(k)
if v is None:
del parsedArgs[k]
continue
dataType = getattr(table, k).dataType.upper()
if not isinstance(v, list):
v = [v]
v = getattr(self, '_check%s' % dataType)(v)
parsedArgs[k] = v
return parsedArgs, parsedKwargs