def execute_get(self, APIName):
dataResult = DataResult()
try:
tasks = {
'getDatabaseInfoById':
lambda: self.getDatabaseInfoById(),
'getDatabaseList':
lambda: self.getDatabaseList(),
'getTableGroupInfoById':
lambda: self.getTableGroupInfoById(),
'getTableGroupList':
lambda: self.getTableGroupList(),
'getTableGroupRelationList':
lambda: self.getTableGroupRelationList(),
# lambda alias
}
self.write(json.dumps(tasks[APIName]().__dict__, cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_get(self,APIName):
dataResult = DataResult()
try:
tasks = {
'getTableInfoById': lambda: self.getTableInfoById(),
'getTableList':lambda :self.getTableList(),
'getColumnInfoById': lambda: self.getColumnInfoById(),
'getColumnListByTableId': lambda: self.getColumnListByTableId(),
'isInitSynchronize': lambda: self.isInitSynchronize(),
'getDataRouteInfoById': lambda: self.getDataRouteInfoById(),
'getDataRouteList': lambda: self.getDataRouteList(),
'getDBLogList': lambda: self.getDBLogList(),
# lambda alias
}
self.write(json.dumps(tasks[APIName]().__dict__,cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_post(self, APIName):
dataResult = DataResult()
try:
tasks = {
'addCaseContent':
lambda: self.addCaseContent(),
'deleteTestContentByContentId':
lambda: self.deleteTestContentByContentId(),
'deleteTestContentByCaseId':
lambda: self.deleteTestContentByCaseId(),
'updateTestContent':
lambda: self.updateTestContent()
}
self.write(json.dumps(tasks[APIName]().__dict__, cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_get(self, APIName):
dataResult = DataResult()
try:
tasks = {
'getCaseInfosByCondition':
lambda: self.getCaseInfosByCondition(),
'getCaseInfosById':
lambda: self.getCaseInfosById(),
'getCaseList':
lambda: self.getCaseList(),
'searchCaseByName':
lambda: self.searchCaseByName(),
'getCaseResultInfosByInstanceId':
lambda: self.getCaseResultInfosByInstanceId()
# lambda alias
}
self.write(json.dumps(tasks[APIName]().__dict__, cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
class DbBaseHelper(object):
def __init__(self,sql=None,args=None,is_execute_many=False):
self.data = DataResult()
self.sql=sql
self.args =args
self.is_execute_many=is_execute_many
#针对select操作
def read(self, **kwargs):
db = Connection(autocommit=False, **kwargs)
try:
if self.args is not None and not isinstance(self.args,dict):
logger.error("sql params [{0}] type is error,must be dict".format(self.args))
self.data.setMessage("sql params type is error,must be dict")
self.data.setSuccess(False)
return self.data
ret = db.read(self.sql,self.args)
self.data.setMessage(list(ret))
self.data.setSuccess(True)
return self.data
except Exception, e:
logger.error("select sql:{0} args:{1} Exception:{2}".format(self.sql,self.args,traceback.format_exc()))
self.data.setSuccess(False)
self.data.setMessage(traceback.format_exc())
self.data.setStatusCode(500)
return self.data
finally:
def execute_post(self, APIName):
dataResult = DataResult()
try:
tasks = {
'addDatabase':
lambda: self.addDatabase(),
'deleteDatabase':
lambda: self.deleteDatabase(),
'editDatabase':
lambda: self.editDatabase(),
'addTableGroup':
lambda: self.addTableGroup(),
'deleteTableGroup':
lambda: self.deleteTableGroup(),
'editTableGroup':
lambda: self.editTableGroup(),
'addTableGroupRelation':
lambda: self.addTableGroupRelation(),
'deleteTableGroupRelation':
lambda: self.deleteTableGroupRelation(),
'updateTableGroupRelation':
lambda: self.updateTableGroupRelation(),
}
self.write(json.dumps(tasks[APIName]().__dict__, cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def __deco(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception, err:
dataResult = DataResult()
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
return dataResult
def execute_post(self, APIName):
dataResult = DataResult()
try:
tasks = {}
self.write(json.dumps(tasks[APIName]().__dict__, cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_post(self, APIName):
dataResult = DataResult()
try:
tasks = {
'addUser': lambda: self.addUser(),
'delete_user_info': lambda: self.delete_user_info(),
'deleteUserInfoByName': lambda: self.deleteUserInfoByName(),
}
self.write(json.dumps(tasks[APIName]().__dict__, cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_post(self,APIName):
dataResult = DataResult()
try:
tasks = {
'addEnvironmentItem' : lambda : self.addEnvironmentItem(),
'deleteEnvironmentItem':lambda :self.deleteEnvironmentItem(),
'editEnvironmentItem' : lambda :self.editEnvironmentItem()
}
self.write(json.dumps(tasks[APIName]().__dict__,cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_get(self,APIName):
dataResult = DataResult()
try:
tasks = {
'get_user_info_by_user_name' : lambda : self.get_user_info_by_user_name(),
'get_user_info_by_user_id' : lambda :self.get_user_info_by_user_id()
# lambda alias
}
self.write(json.dumps(tasks[APIName]().__dict__,cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_get(self, APIName):
dataResult = DataResult()
# try:
# if not self.current_user:
# dataResult.setSuccess(False)
# dataResult.setMessage("目前处于未登录状态，请登录")
# self.write(json.dumps(dataResult.__dict__, cls=CJsonEncoder))
# else:
# tasks = {
# 'getUserInfo' : lambda : self.getUserInfo(),
# 'get_user_info_by_user_id' : lambda :self.get_user_info_by_user_id(),
# 'getUserList' : lambda :self.getUserList()
# # lambda alias
# }
# self.write(json.dumps(tasks[APIName]().__dict__,cls=CJsonEncoder))
try:
tasks = {
'getUserInfo': lambda: self.getUserInfo(),
'get_user_info_by_user_id':
lambda: self.get_user_info_by_user_id(),
'getUserList': lambda: self.getUserList(),
'getUserByUnionid': lambda: self.getUserByUnionid(),
'getUserDingDingInfo': lambda: self.getUserDingDingInfo(),
'getCurrentUser': lambda: self.getCurrentUser(),
'getCurrentUserIsleader':
lambda: self.getCurrentUserIsleader(),
# lambda alias
}
self.write(json.dumps(tasks[APIName]().__dict__, cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_post(self,APIName):
dataResult = DataResult()
try:
tasks = {
'getTableInfoByName': lambda: self.getTableInfoByName(),
'addTable' : lambda : self.addTable(),
'deleteTable':lambda :self.deleteTable(),
'editTable':lambda :self.editTable(),
'editTableByName':lambda :self.editTableByName(),
'discardTableByName':lambda :self.discardTableByName(),
'getColumnListByTableName': lambda: self.getColumnListByTableName(),
'addColumn': lambda: self.addColumn(),
'deleteColumn': lambda: self.deleteColumn(),
'editColumn': lambda: self.editColumn(),
'initSynchronizeDatabase': lambda: self.initSynchronizeDatabase(),
'synchronizeDatabase': lambda: self.synchronizeDatabase(),
'initSynchronizeTable': lambda: self.initSynchronizeTable(),
'initSynchronizeColumn': lambda: self.initSynchronizeColumn(),
'addDataRoute': lambda: self.addDataRoute(),
'deleteDataRoute': lambda: self.deleteDataRoute(),
'editDataRoute': lambda: self.editDataRoute(),
'editColumnRemarkById': lambda: self.editColumnRemarkById(),
'editColumnDiscardById': lambda: self.editColumnDiscardById(),
'getSearchByTable': lambda: self.getSearchByTable(),
'getSearchByTableColumn': lambda: self.getSearchByTableColumn(),
'getSearchByColumn': lambda: self.getSearchByColumn(),
}
self.write(json.dumps(tasks[APIName]().__dict__,cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_post(self, APIName):
dataResult = DataResult()
try:
tasks = {
'addInterfaceItem': lambda: self.addInterfaceItem(),
'deleteInterfaceItem': lambda: self.deleteInterfaceItem(),
'updateInterfaceItem': lambda: self.updateInterfaceItem(),
'enableInterfaceItem': lambda: self.enableInterfaceItem(),
'disableInterfaceItem': lambda: self.disableInterfaceItem(),
'setInterfaceGroup': lambda: self.setInterfaceGroup(),
}
self.write(json.dumps(tasks[APIName]().__dict__, cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_get(self,APIName):
dataResult = DataResult()
try:
tasks = {
'getWebApiForVersion': lambda: self.getWebApiForVersion(),
'getWebApiInfoById':lambda :self.getWebApiInfoById(),
'getWebApiList': lambda : self.getWebApiList(),
'getWebApiInfoByPath':lambda :self.getWebApiInfoByPath(),
'synchronizeWebApi':lambda :self.synchronizeWebApi(),
# lambda alias
}
self.write(json.dumps(tasks[APIName]().__dict__,cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def __deco(*args, **kwargs):
dataResult = DataResult()
try:
isAdmin = False
ips = adminIps.split(",")
#get remote ip of client
remote_ip = args[0].__dict__['request'].remote_ip
for ip in ips:
if remote_ip == ip:
isAdmin = True
if not isAdmin:
dataResult.setSuccess(False)
dataResult.setMessage(
"Request IP [{0}]without a white list，to be intercepted"
.format(remote_ip))
return dataResult
return func(*args, **kwargs)
except Exception, err:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
return dataResult
def execute_get(self,APIName):
dataResult = DataResult()
try:
tasks = {
'getProjectInfoByName' : lambda : self.getProjectInfoByName(),
'getProjectInfoById': lambda: self.getProjectInfoById(),
'getProjectList':lambda :self.getProjectList(),
'getProjectLogListData':lambda :self.getProjectLogListData(),
'getProjectListByApplicationId' :lambda :self.getProjectListByApplicationId(),
# lambda alias
}
self.write(json.dumps(tasks[APIName]().__dict__,cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
def execute_post(self,APIName):
dataResult = DataResult()
try:
tasks = {
'addApplication' : lambda : self.addApplication(),
'addApplicationVersion' : lambda : self.addApplicationVersion(),
'deleteApplicationVersion' : lambda :self.deleteApplicationVersion(),
'addApplicationVersionConfig' : lambda :self.addApplicationVersionConfig(),
'editVersionConfig' : lambda :self.editVersionConfig(),
'editApplication': lambda: self.editApplication(),
'deleteApplication' :lambda :self.deleteApplication(),
}
self.write(json.dumps(tasks[APIName]().__dict__,cls=CJsonEncoder))
except:
logger.error(traceback.format_exc())
dataResult.setMessage(traceback.format_exc())
dataResult.setSuccess(False)
dataResult.setStatusCode(500)
self.write(json.dumps(dataResult.__dict__))
finally:
try:
self.finish()
except:
pass
class DbBaseHelper(object):
def __init__(self, sql=None, args=None, is_execute_many=False):
self.data = DataResult()
self.sql = sql
self.args = args
self.is_execute_many = is_execute_many
#针对select操作
def read(self, **kwargs):
db = Connection(autocommit=False, **kwargs)
try:
if self.args is not None and not isinstance(self.args, dict):
logger.error(
"sql params [{0}] type is error,must be dict".format(
self.args))
self.data.setMessage("sql params type is error,must be dict")
self.data.setSuccess(False)
return self.data
ret = db.read(self.sql, self.args)
self.data.setMessage(list(ret))
self.data.setSuccess(True)
return self.data
except Exception as e:
logger.error("select sql:{0} args:{1} Exception:{2}".format(
self.sql, self.args, traceback.format_exc()))
self.data.setSuccess(False)
self.data.setMessage(traceback.format_exc())
self.data.setStatusCode(500)
return self.data
finally:
db.close()
# 针对update、insert、delete操作，is_execute_many=True 支持批量插入和更新
def write(self):
db = Connection(autocommit=False)
try:
if self.is_execute_many:
if not isinstance(self.args, list):
logger.error(
"sql params [{0}] type is error,must be list".format(
self.args))
self.data.setMessage(
"sql params type is error,must be list")
self.data.setSuccess(False)
return self.data
elif self.args is not None and not isinstance(self.args, dict):
logger.error(
"sql params [{0}] type is error,must be dict".format(
self.args))
self.data.setMessage("sql params type is error,must be dict")
self.data.setSuccess(False)
return self.data
ret = db.write(self.sql, self.args, self.is_execute_many)
db.commit()
self.data.setMessage(ret)
self.data.setSuccess(True)
return self.data
except Exception as e:
logger.error("write sql:{0} args:{1} Exception:{2}".format(
self.sql, self.args, traceback.format_exc()))
self.data.setSuccess(False)
self.data.setMessage(traceback.format_exc())
self.data.setStatusCode(500)
return self.data
finally:
db.close()
def execReadOnlySQL(self, dbConfig, sql):
db = Connection(autocommit=False, **dbConfig)
try:
ret = db.read(sql)
return list(ret)
except Exception as e:
logger.error("execReadOnlySQL Exception:sql{0} reason:{1}".format(
sql, traceback.format_exc()))
return []
finally:
db.close()
