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_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 login_info(self):
unionid = self.get_argument("unioinid")
logger.info(unionid)
args_unionid = {}
args_unionid.setdefault("unionid", unionid)
data = UserService.getUserByUnionid(args_unionid)
logger.info(data)
if data.getSuccess() and len(data.getMessage()) > 0:
request_data = {}
request_data.setdefault("userName", data.username)
request_data.setdefault("userPasswd", data.passwd)
return LoginHandler.auth_login(request_data)
elif data.getSuccess() and len(data.getMessage()) == 0:
# userinfo = requests.post(url="http://dev2-stpuser.greedyint.com/user/GetDingTalkUserDetail",data=args_unionid,headers={"Content-Type":"application/json"})
userinfo = requests.post(
url=
"http://user-sign.xiaobao100.com/user/GetDingTalkUserDetail",
data=args_unionid,
headers={"Content-Type": "application/json"})
request_data = {}
request_data.setdefault("userName", userinfo.name)
request_data.setdefault("userPasswd", 123456)
request_data.setdefault("mobile", userinfo.mobile)
request_data.setdefault("userid_ding", userinfo.userid)
request_data.setdefault("unionid", userinfo.unionid)
request_data.setdefault("ding_department_id",
userinfo.department[0])
request_data.setdefault("roles", "")
return UserService.addUser(request_data)
DataResult.setMessage("请联系管理员")
DataResult.setSuccess(False)
return DataResult
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
def getGroupByProjectId(self, projectId, type):
treeResult = DataResult()
trees = []
args = {}
args.setdefault("projectId", projectId)
args.setdefault("type", type)
args.setdefault("parentGroupId", 0)
#先查根结点
dataResult = self.GroupDaoInterface.getGroupInfoByParentGroupId(args)
if dataResult.getSuccess():
for item in dataResult.getMessage():
data = {}
data["children"] = []
data["title"] = item["name"]
data["expand"] = True
data["parentGroupId"] = item["parent_groupid"]
data["groupId"] = item["id"]
#查找子节点
args.pop("parentGroupId")
args.setdefault("parentGroupId", item["id"])
sonNodes = self.GroupDaoInterface.getGroupInfoByParentGroupId(
args)
if sonNodes.getSuccess():
for sonItem in sonNodes.getMessage():
sonData = {}
sonData["children"] = []
sonData["title"] = sonItem["name"]
sonData["expand"] = True
sonData["parentGroupId"] = sonItem["parent_groupid"]
sonData["groupId"] = sonItem["id"]
data["children"].append(sonData)
trees.append(data)
treeResult.setMessage(trees)
treeResult.setSuccess(True)
return treeResult
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 __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 postByCase(self):
dataResult = DataResult()
headers = {}
if self.format is not None:
headers["contentType"] = self.format
r = requests.Session().post(self.url,
params=self.params,
headers=headers,
verify=False)
dataResult.setMessage(r.text)
dataResult.setSuccess(True)
return dataResult
def getUserDingDingInfo(self):
unionid = self.get_argument('unionid')
args = {}
args.setdefault("unionid", unionid)
userInfo = requests.post(
url="http://dev2-stpuser.greedyint.com/user/GetDingTalkUserDetail",
data=json.dumps(args),
headers={"Content-Type": "application/json"})
dataResult = json.loads(userInfo.text)
Result = DataResult()
Result.setSuccess(True)
Result.setMessage(dataResult)
logger.info(Result)
return Result
def getWebApiList(self, applicationId, projectId):
webApiResult = DataResult()
webApi = []
args = {}
args.setdefault("applicationId", applicationId)
args.setdefault("projectId", projectId)
dataResult = self.WebApiDaoInterface.getWebApiList(args)
if dataResult.getSuccess():
for item in dataResult.getMessage():
data = {}
data["Id"] = item["Id"]
data["Method"] = item["Method"]
data["OperationId"] = item["OperationId"]
data["Path"] = item["Path"]
data["Produces"] = item["Produces"]
data["Summary"] = item["Summary"]
data["DiffType"] = item["DiffType"]
Id = {"Id": item["Id"]}
# data["Type"]="query"
data_request = self.WebApiDaoInterface.getWebApiRequest(Id)
if data_request.getSuccess():
data["Schema_request"] = []
if len(data_request.getMessage()) > 0:
if data_request.getMessage()[0]["In"] == "query":
for res in data_request.getMessage():
if res["Required"] == 1:
data["Type"] = "query"
tmpJson = {}
tmpJson["name"] = res["Name"]
tmpJson["defaultValue"] = res["Schema"]
tmpJson["describe"] = res["Description"]
data["Schema_request"].append(tmpJson)
else:
data["Type"] = "body"
data["Schema_request"] = data_request.getMessage(
)[0]["Schema"]
else:
data["Type"] = ""
data["Schema_request"] = []
logger.info(data["Schema_request"])
data_response = self.WebApiDaoInterface.getWebApiResponse(Id)
if data_response.getSuccess():
data["Schema_response"] = data_response.getMessage(
)[0]["Schema"]
logger.info(data["Schema_response"])
webApi.append(data)
webApiResult.setMessage(webApi)
webApiResult.setSuccess(True)
return webApiResult
def getCount(self):
args = {}
args["createUser"] = UserService().getUserCount().getMessage(
)[0]["userCount"]
args["project"] = ProjectService().getProjectCount().getMessage(
)[0]["projectCount"]
args["application"] = ApplicationService().getApplicationCount(
).getMessage()[0]["applicationCount"]
args["testCase"] = TestCaseService().getTestCaseCount().getMessage(
)[0]["testCaseCount"]
dataResult = DataResult()
dataResult.setMessage(args)
dataResult.setSuccess(True)
logger.info(dataResult)
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 synchronizeWebApi(self):
swaggerJsonOrUrl = self.get_argument('swaggerJsonOrUrl')
projectId = self.get_argument('projectId')
applicationId=self.get_argument('applicationId')
args = {}
args.setdefault("swaggerJsonOrUrl", swaggerJsonOrUrl)
args.setdefault("projectId", projectId)
args.setdefault("applicationId", applicationId)
response = requests.post(url="http://192.168.50.27:83/api/swaggerservice/createwebapis",
data=json.dumps(args), headers={"Content-Type": "application/json"})
dataResult = json.loads(response.text)
Result = DataResult()
Result.setSuccess(True)
Result.setMessage(dataResult)
logger.info(Result)
return Result
def confirmDatabasePwdById(self, args):
result = DataResult()
bu = args["bu"]
src_key = args["key"]
str_bu = ""
if bu == 1:
str_bu = "NBU"
elif bu == 2:
str_bu = "TBU"
elif bu == 3:
str_bu = "IBU"
key = "{}{}".format(bu, str_bu)
if key == src_key:
result.setMessage("秘钥正确")
result.setSuccess(True)
else:
result.setMessage("秘钥错误")
return result
def addEnvironmentItem(self, args):
if "url" not in args:
args.setdefault("url", None)
if "template" not in args:
args.setdefault("template", None)
else:
if not isinstance(args.get("template"), dict):
try:
#验证data模板是否为json
logger.info("template is not dict:{0}".format(
args.get("template")))
datatemplate = json.dumps(json.loads(args.get("template")))
# logger.error(datatemplate)
# logger.error(type(datatemplate))
args.pop("template")
args.setdefault("template", datatemplate)
except Exception:
logger.error(traceback.format_exc())
dataResult = DataResult()
dataResult.setMessage(
"template param [{0}]is invalid, must be dict".format(
args.get("template")))
dataResult.setSuccess(False)
return dataResult
else:
logger.info("template is dict:{0}".format(
args.get("template")))
datatemplateJSONString = json.dumps(args.get("template"))
# logger.error(datatemplateJSONString)
args.pop("template")
args.setdefault("template", datatemplateJSONString)
if "dbname" not in args:
args.setdefault("dbname", None)
if "dbhostname" not in args:
args.setdefault("dbhostname", None)
if "dbport" not in args:
args.setdefault("dbport", None)
if "dbusername" not in args:
args.setdefault("dbusername", None)
if "dbpasswd" not in args:
args.setdefault("dbpasswd", None)
return self.EnvironmentDaoInterface.addEnvironmentItem(args)
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 __execAssertJob(actual, expect, assert_type="0"):
#equal
if assert_type == "0":
result = AssertInstance.get_instance().isEqual(actual, expect)
#not equal
elif assert_type == "1":
result = AssertInstance.get_instance().notEqual(actual, expect)
#contain
elif assert_type == "2":
result = AssertInstance.get_instance().isContain(actual, expect)
#not contain
elif assert_type == "3":
result = AssertInstance.get_instance().notContain(actual, expect)
else:
result = False
assertResult = DataResult()
assertResult.setSuccess(result)
assertResult.setMessage("Notice:actual={0},expect={1}\n".format(
actual, expect))
return assertResult
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_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 editEnvironmentItem(self, args):
if "template" not in args:
args.setdefault("template", None)
else:
if not isinstance(args.get("template"), dict):
try:
#验证data模板是否为json
logger.info("template is not dict:{0}".format(
args.get("template")))
datatemplate = json.dumps(json.loads(args.get("template")))
args.pop("template")
args.setdefault("template", datatemplate)
except Exception, err:
logger.error(traceback.format_exc())
dataResult = DataResult()
dataResult.setMessage(
"template param [{0}]is invalid, must be dict".format(
args.get("template")))
dataResult.setSuccess(False)
return dataResult
else:
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
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 = {
'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 __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_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 = {
'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_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 editEnvironmentItem(self, args):
if "template" not in args:
args.setdefault("template", None)
else:
if not isinstance(args.get("template"), dict):
try:
#验证data模板是否为json
logger.info("template is not dict:{0}".format(
args.get("template")))
datatemplate = json.dumps(json.loads(args.get("template")))
args.pop("template")
args.setdefault("template", datatemplate)
except Exception as err:
logger.error(traceback.format_exc())
dataResult = DataResult()
dataResult.setMessage(
"template param [{0}]is invalid, must be dict".format(
args.get("template")))
dataResult.setSuccess(False)
return dataResult
else:
logger.info("template is dict:{0}".format(
args.get("template")))
datatemplateJSONString = json.dumps(args.get("template"))
args.pop("template")
args.setdefault("template", datatemplateJSONString)
dataResult = self.EnvironmentDaoInterface.getEnvironmentInfoById(args)
if dataResult.getSuccess() and len(dataResult.getMessage()) > 0:
for key, value in dataResult.getMessage()[0].items():
if key not in args:
args.setdefault(key, value)
return self.EnvironmentDaoInterface.editEnvironmentItem(args)
dataResult.setMessage("apiId [{0}] is invalid".format(
args.get("envId")))
return dataResult
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
