def post(self):
parser = reqparse.RequestParser()
parser.add_argument('modelUID', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[DeleteModel] args: {args}")
modelUID = args['modelUID']
token = args['token']
#check user isLogin
if tokenValidator(args['token']):
try:
status, resp = ModelService().deleteModel(modelUID, token)
if (status):
return {"status": "success", "msg": "", "data": {}}, 200
else:
return resp
except Exception as e:
logging.error(str(e))
return {"status": "error", "msg": f"{e}", "data": {}}, 500
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('fileID', type=str, required=True)
parser.add_argument('fileName', type=str, required=False)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[DownloadFile] args: {args}")
fileID = args['fileID']
fileName = args['fileName']
#check user isLogin
if tokenValidator(args['token']):
try:
form = {'fileUid': fileID, 'fileName': fileName}
logging.info(f'form:{form}')
resp = requests.get(coreApi.Download, data=form)
logging.info(resp)
# with open('111.zip', 'wb') as file:
# file.write(resp.content)
response = make_response(resp.content)
response.headers['Content-Type'] = 'application/octet-stream;'
return response
except Exception as e:
logging.error(str(e))
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
try:
parser=reqparse.RequestParser()
parser.add_argument('token',type=str,required=True)
parser.add_argument('modelUid',type=str,required=True)
args=parser.parse_args()
if not tokenValidator(args['token']):
return {"status":"error","msg":"token error","data":{}},401
args.pop('token')
logging.info(f'[API_deleteModel] args:{args}')
mid=args['modelUid']
_,modelFid,_,_,_,status,_,_=getModelInfo(mid)[0]
if status=='train':
return {"status":"error","msg":f"model {mid} is still training. Can't delete","data":{}},400
try:
shutil.rmtree(os.path.join(param.modelpath,mid))
except FileNotFoundError:
pass
try:
db=sql()
db.cursor.execute(f"delete from `models` where `mid`='{mid}';")
numOfresult=db.cursor.execute(f"select * from `models` where (`fid`='{modelFid}' and (`status`='train' or `status`='success'));")
if numOfresult==0:
unlockFile(modelFid)
db.conn.commit()
except Exception as e:
db.conn.rollback()
raise e
finally:
db.conn.close()
return {"status":"success","msg":"","data":{}},200
except Exception as e:
logging.error(f"[API_deleteModel]{traceback.format_exc()}")
return {"status":"error","msg":str(traceback.format_exc()),"data":{}},400
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('fileID', type=str, required=True)
parser.add_argument('algoName', type=str, required=True)
parser.add_argument('dataCol', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[dataViz] args: {args}")
fileID = args['fileID']
algoName = args['algoName']
dataCol = args['dataCol']
token = args['token']
#check user isLogin
if tokenValidator(token):
form = {
'fileUid': fileID,
'algoname': algoName,
'datacol': dataCol,
'token': token
}
resp = requests.post(coreApi.DoDataViz, data=form)
response = resp.json()
return response
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('dataType', type=str, required=True)
parser.add_argument('projectType', type=str, required=True)
parser.add_argument('algoName', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[GetAnalyticAlgoParam] args: {args}")
dataType = args['dataType']
projectType = args['projectType']
algoName = args['algoName']
token = args['token']
#check user isLogin
if tokenValidator(token):
form = {
'dataType': dataType,
'projectType': projectType,
'algoName': algoName
}
resp = requests.get(coreApi.GetAnalyticAlgoParam, data=form)
response = resp.json()
if response['status'] == 'success':
return resp.json(), 200
else:
return resp.json(), 500
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
try:
parser=reqparse.RequestParser()
parser.add_argument('token',type=str,required=True)
parser.add_argument('modelUid',type=str,required=True)
parser.add_argument('fileUid',type=str,required=True)
parser.add_argument('label',type=str)
args=parser.parse_args()
if not tokenValidator(args['token']):
return {"status":"error","msg":"token error","data":{}},401
args.pop('token')
logging.info(f'[API_doModelTest] args:{args}')
mid=args['modelUid']
fid=args['fileUid']
_,_,_,_,_,status,_,_=getModelInfo(mid)[0]
if status!='success':
return {"status":"error","msg":f"model {mid} is still training or failed. Can't test","data":{}},400
with open(os.path.join(param.modelpath,mid,'algoInfo.pkl'),'rb') as file:
algoInfo=pickle.load(file)
module=importlib.import_module(f"service.analyticService.core.analyticCore.{algoInfo['dataType']}.{algoInfo['projectType']}.{algoInfo['algoName']}")
importlib.reload(module)
attr=getattr(module,algoInfo['algoName'])
if algoInfo['projectType']=='abnormal':
algo=attr(algoInfo,fid,'test',mid=mid,testLabel=args['label'])
else:
algo=attr(algoInfo,fid,'test',mid=mid)
algo.predictWrapper()
result=algo.test()
return {"status":"success","msg":"","data":result},200
except Exception as e:
logging.error(f"[API_doModelTest]{traceback.format_exc()}")
return {"status":"error","msg":str(traceback.format_exc()),"data":{}},400
def post(self):
fName = 'API_doPreprocess'
try:
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
parser.add_argument('fileUid', type=str, required=True)
parser.add_argument('action', type=str, required=True)
args = parser.parse_args()
fid = args['fileUid']
token = args['token']
if not tokenValidator(token):
return {
"status": "error",
"msg": "token error",
"data": {}
}, 401
args.pop('token')
logging.info(f"[{fName}] args: {args}")
try:
action = json.loads(args['action'])
except Exception as e:
return {
"status": "error",
"msg": "can't parse action json",
"data": {}
}, 400
uid = core(fid, action).do()
return {"status": "success", "msg": "", "data": {"fileUid": uid}}
except Exception as e:
logging.error(f"[{fName}] {traceback.format_exc()}")
return {
"status": "error",
"msg": str(traceback.format_exc()),
"data": {}
}, 400
def get(self):
try:
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
parser.add_argument('fileUid', type=str, required=True)
args = parser.parse_args()
if not tokenValidator(args['token']):
return {
"status": "error",
"msg": "token error",
"data": {}
}, 401
args.pop('token')
logging.info(f'[API_getFileParameter] args:{args}')
fid = args['fileUid']
_, _, _, _, _, preprocessActionFile = getFileInfo(fid)[0]
if preprocessActionFile:
with open(preprocessActionFile) as file:
action = json.load(file)
else:
return {
"status": "error",
"msg":
f"file {fid} doesnt have related preprocessing records",
"data": {}
}, 400
return {"status": "success", "msg": "", "data": action}, 200
except Exception as e:
logging.error(f"[API_getModelParameter]{traceback.format_exc()}")
return {
"status": "error",
"msg": str(traceback.format_exc()),
"data": {}
}, 400
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('fileID', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[GetFileColumn] args: {args}")
fileID = args['fileID']
token = args['token']
#check user isLogin
if tokenValidator(token):
form = {'fileUid': fileID, 'token': token}
response = requests.post(coreApi.GetColumn, data=form)
responseObj = response.json()
logging.info(f'result: {responseObj}')
return responseObj
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
'''
@ fileUid: file id
@ tokenstr: keypair1
@ tokenint: keypair2
'''
fName = '[API_getCol]'
parser = reqparse.RequestParser()
parser.add_argument('fileUid', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
fid = args['fileUid']
token = args['token']
#check token
if not tokenValidator(token):
return {"status": "error", "msg": "token error", "data": {}}, 401
args.pop('token')
logging.debug(f"[API_getCol] args: {args}")
try:
fileInfo = getFileInfo(fid)
except Exception as e:
logging.error(f'{fName}{e}')
return {'status': 'error', 'msg': str(e), 'data': {}}, 400
fileInfo = fileInfo[0]
filePath = fileInfo[3]
dataType = fileInfo[1]
try:
gct = getColType(filePath, dataType).get()
except Exception as e:
logging.error(f'{fName}{e}')
return {'status': 'error', 'msg': str(e), 'data': {}}, 400
return {'status': 'success', 'msg': '', 'data': {"cols": gct}}, 200
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('projectID', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[GetFileList] args: {args}")
projectID = args['projectID']
token = args['token']
#check user isLogin
if tokenValidator(token):
resp = []
try:
db = sql()
db.cursor.execute(
f"select * from file where `project_id`='{projectID}'")
result = db.cursor.fetchall()
data = [list(a) for a in result]
for item in data:
form = {'fileUids': json.dumps([item[0]]), 'token': token}
logging.info(f'form:{form}')
response = requests.post(coreApi.GetFileStatus, data=form)
responseObj = response.json()
if responseObj["status"] == 'success':
respItem = {
'fileID': item[0],
'fileName': item[1][:(item[1].rfind("."))],
'fileType': item[1][(item[1].rfind(".") + 1):],
'fileStatus': responseObj["data"]["status"][0]
}
db.cursor.execute(
f"select Count(*) from model where `file_id`='{item[0]}'"
)
result = db.cursor.fetchall()
if result[0][0] > 0:
respItem['fileStatus'] = 1
resp.append(respItem)
except Exception as e:
logging.error(str(e))
db.conn.rollback()
finally:
db.conn.close()
logging.debug(f"[GetFileList] resp: {resp}")
return {
"status": "success",
"msg": "",
"data": {
'fileList': resp
}
}, 200
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('projectID', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[DeleteProject] args: {args}")
projectID = args['projectID']
#check user isLogin
if tokenValidator(args['token']):
try:
db = sql()
db.cursor.execute(
f"select `file_id` from file where `project_id`='{projectID}'"
)
result = db.cursor.fetchall()
fileIDList = [a[0] for a in result]
for fileID in fileIDList:
form = {'fileUid': fileID, 'token': args['token']}
response = requests.post(coreApi.DeleteFile, data=form)
responseObj = response.json()
if responseObj["status"] == "success":
db.cursor.execute(
f"delete from file where `file_id` = '{fileID}'")
db.conn.commit()
continue
else:
return responseObj, 400
if deleteModelByProject.delete(projectID,
args['token']) != True:
return {
"status": "error",
"msg": "delete project error",
"data": {}
}, 400
db.cursor.execute(
f"delete from project where `project_id` = '{projectID}'")
db.conn.commit()
logging.info(f"[DeleteProject] OK with project id {projectID}")
return {"status": "success", "msg": "", "data": {}}, 200
except Exception as e:
db.conn.rollback()
logging.error(e)
return {"status": "error", "msg": f"{e}", "data": {}}, 400
finally:
db.conn.close()
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
parser.add_argument('keyword', type=str, required=True)
args = parser.parse_args()
keyword = args['keyword']
token = args['token']
#check user isLogin
if tokenValidator(token):
resp = []
try:
if (keyword == ''):
db = sql()
db.cursor.execute(
f"select * from RPA where `top_version` = 'Y'")
result = db.cursor.fetchall()
else:
db = sql()
db.cursor.execute(
f"select * from RPA where `top_version` = 'Y' AND match (`description`, `name`) against ('{keyword}' in BOOLEAN MODE) > 0.001"
)
result = db.cursor.fetchall()
logging.info(result)
data = [list(a) for a in result]
for item in data:
db = sql()
db.cursor.execute(
f"select * from user where `user_id`='{item[0]}'")
result = db.cursor.fetchone()
respItem = {
'RPAID': item[3],
'RPADescription': item[5],
'RPAName': item[6],
'userName': result[1],
'projectID': item[1]
}
resp.append(respItem)
return {
"status": "success",
"msg": "",
"data": {
'rpaList': resp
}
}, 200
except Exception as e:
logging.debug(f"[getRPA] error: {e}")
return {"status": "error", "msg": f"{e}", "data": {}}, 200
db.conn.rollback()
finally:
db.conn.close()
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('file', type=FileStorage, location='files',required=True)
parser.add_argument('userID',type=str,required=True)
parser.add_argument('projectID',type=str,required=True)
parser.add_argument('token',type=str,required=True)
args = parser.parse_args()
logging.debug(f"[ImportRPA] args: {args}")
file = args['file']
userID=args['userID']
projectID=args['projectID']
token = args['token']
#check user isLogin
if tokenValidator(token):
#check filetype
filename=file.filename
filetype=filename[filename.rfind("."):]
logging.debug(f"[ImportRPA] File type:{filetype}")
if filetype != '.json':
return {"status":"error","msg":"file type error","data":{}},400
uid = RPAUidGenerator().uid
savedPath=param.RPAFilepath +'\\'+ uid + '.json'
try:
file.save(savedPath)
except Exception as e:
return {"status":"error","msg":f"file error:{e}","data":{}},400
try:
fileChecker(savedPath).check()
except Exception as e:
return {"status":"error","msg":str(e),"data":{}},400
try:
db=sql()
db.cursor.execute(f"select MAX(version) from RPA where `project_id`='{projectID}'")
result, = db.cursor.fetchone()
if result == None:
version = 1
else:
version = result + 1
db.cursor.execute(f"update RPA set `top_version`='N' where `user_id` = '{userID}' and `project_id` = '{projectID}'")
db.conn.commit()
db.cursor.execute(f"insert into RPA (`user_id`,`project_id`, `version`, `RPA_id`, `top_version`, `name`, `description`) values ('{userID}','{projectID}','{version}','{uid}','Y', '', '');")
db.conn.commit()
return {"status":"success","msg":"","data":{"RPAID":uid}},201
except Exception as e:
logging.debug(f"[ImportRPA] error: {e}")
db.conn.rollback()
return {"status":"error","msg":"","data":{}},400
finally:
db.conn.close()
else:
return {"status":"error","msg":"user did not login","data":{}},401
def post(self):
'''
@ type: num/cv/nlp
@ file: a file
@ tokenstr: keypair1
@ tokenint: keypair2
'''
parser = reqparse.RequestParser()
parser.add_argument('fileUid', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
fid = args['fileUid']
token = args['token']
#check token
if not tokenValidator(token):
return {"status": "error", "msg": "token error", "data": {}}, 401
try:
fileInfo = getFileInfo(fid)
except Exception as e:
logging.error(f'[Delfile]{e}')
return {'status': 'error', 'msg': str(e), 'data': {}}, 400
fileInfo = fileInfo[0]
if fileInfo[3] == 1:
logging.warning(f'[API_DelFile] file {fid} in use')
return {
"status": "error",
"msg": "The file is in-used",
"data": {}
}, 400
filePath = fileInfo[2]
dataType = fileInfo[1]
actionFile = fileInfo[5]
if dataType == 'cv':
shutil.rmtree(filePath)
else:
os.remove(filePath)
if actionFile:
os.remove(actionFile)
try:
db = sql()
db.cursor.execute(f"delete from files where fid='{fid}'")
db.conn.commit()
except Exception as e:
logging.error(f"[API_DelFile] {e}")
finally:
db.conn.close()
logging.info(f"[API_DelFile] OK with file uid {fid}")
return {"status": "success", "msg": "", "data": {}}, 201
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('token',type=str,required=True)
args = parser.parse_args()
logging.debug(f"[GetVisAlgoList] args: {args}")
token = args['token']
#check user isLogin
if tokenValidator(token):
resp = requests.get(coreApi.GetDataVizAlgoList)
return resp.json()
else:
return {"status":"error","msg":"user did not login","data":{}},401
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
parser.add_argument('modelIndex', type=str, required=True)
parser.add_argument('fileID', type=str, required=True)
parser.add_argument('label', type=str)
args = parser.parse_args()
logging.debug(f"[DoModelTest] args: {args}")
modelIndex = args['modelIndex']
token = args['token']
fileID = args['fileID']
label = args['label']
if label == None:
label = ''
#check user isLogin
if tokenValidator(token):
try:
db = sql()
db.cursor.execute(
f"select * from model where `model_index`='{modelIndex}'")
result = db.cursor.fetchone()
if (result[1] != None):
form = {
'modelUid': result[1],
'fileUid': fileID,
'label': label,
'token': token
}
resp = requests.post(coreApi.DoModelTest, data=form)
response = resp.json()
return response, 200
else:
return {
"status": "error",
"msg": "model id or file id not found",
"data": {}
}, 500
except Exception as e:
logging.error(str(e))
db.conn.rollback()
finally:
db.conn.close()
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
fName = '[AddCourse]'
parser = reqparse.RequestParser()
parser.add_argument('courseName', type=str, required=True)
parser.add_argument('courseYear', type=str, required=True)
parser.add_argument('jobName', type=str, required=True)
parser.add_argument('deadline', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
courseName = args['courseName']
courseYear = args['courseYear']
jobName = args['jobName']
deadline = args['deadline']
token = args['token']
#check user isLogin
if tokenValidator(token):
args.pop('token')
logging.debug(f"[AddCourse] args: {args}")
#generate course UID and save
uid = courseIndexGenerator().uid
logging.debug(f'[AddCourse] course UID:{uid}')
try:
db = sql()
db.cursor.execute(
f"insert into course (`course_id`,`course_name`,`course_year`,`course_jobName`,`course_deadline`) values ('{uid}','{courseName}','{courseYear}','{jobName}','{deadline}');"
)
db.conn.commit()
return {
"status": "success",
"msg": "",
"data": {
"courseID": uid
}
}, 201
except Exception as e:
logging.error(str(e))
return {"status": "error", "msg": str(e), "data": {}}, 400
finally:
db.conn.close()
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('FileIndex', type=str, required=True)
parser.add_argument('token', type=str, required=True)
parser.add_argument('dataType', type=str, required=True)
parser.add_argument('projectType', type=str, required=True)
parser.add_argument('algoName', type=str, required=True)
parser.add_argument('param', type=str, required=True)
parser.add_argument('input', type=str, required=True)
parser.add_argument('output', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[DoModelTrain] args: {args}")
fileIndex = args['FileIndex']
token = args['token']
dataType = args['dataType']
projectType = args['projectType']
algoName = args['algoName']
param = args['param']
inputColumn = args['input']
output = args['output']
#check user isLogin
if tokenValidator(token):
try:
response = AnalyticService().trainModel(
token, fileIndex, dataType, projectType, algoName, param,
inputColumn, output)
if response['status'] == 'success':
try:
return response, 200
except Exception as e:
logging.error(str(e))
else:
return {
"status": "error",
"msg": response['msg'],
"data": {}
}, 500
except Exception as e:
logging.error(str(e))
return {"status": "error", "msg": f"{str(e)}", "data": {}}, 500
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
fName = 'API_preprocessPreview'
try:
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
parser.add_argument('fileUid', type=str, required=True)
parser.add_argument('action', type=str, required=True)
args = parser.parse_args()
fid = args['fileUid']
token = args['token']
if not tokenValidator(token):
return {
"status": "error",
"msg": "token error",
"data": {}
}, 401
args.pop('token')
logging.info(f"[{fName}] args: {args}")
try:
action = json.loads(args['action'])
except Exception as e:
return {
"status": "error",
"msg": "can't parse action json",
"data": {}
}, 400
msg, beforeComp, afterComp = core(fid, action).preview()
response = make_response(
json.dumps({
'status': 'success',
'msg': '',
'data': {
"msg": msg,
"beforeComp": beforeComp,
"afterComp": afterComp
}
}))
response.headers['Access-Control-Allow-Origin'] = '*'
response.headers[
'Access-Control-Allow-Methods'] = 'OPTIONS,HEAD,GET,POST'
response.headers[
'Access-Control-Allow-Headers'] = 'x-requested-with'
return response
except Exception as e:
logging.error(f"[{fName}] {traceback.format_exc()}")
return {
"status": "error",
"msg": str(traceback.format_exc()),
"data": {}
}, 400
def post(self):
fName = '[ModifyCourse]'
parser = reqparse.RequestParser()
parser.add_argument('courseID', type=str, required=True)
parser.add_argument('courseName', type=str, required=True)
parser.add_argument('courseYear', type=str, required=True)
parser.add_argument('jobName', type=str, required=True)
parser.add_argument('deadline', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
courseID = args['courseID']
courseName = args['courseName']
courseYear = args['courseYear']
jobName = args['jobName']
deadline = args['deadline']
token = args['token']
#check user isLogin
if tokenValidator(token):
args.pop('token')
logging.debug(f"[ModifyCourse] args: {args}")
try:
db = sql()
db.cursor.execute(
f"update course set `course_name`='{courseName}', `course_year`='{courseYear}', `course_jobName`='{jobName}', `course_deadline`='{deadline}' where `course_id`='{courseID}'"
)
db.conn.commit()
return {
"status": "success",
"msg": "",
"data": {
"courseID": courseID
}
}, 200
except Exception as e:
logging.error(str(e))
return {"status": "error", "msg": str(e), "data": {}}, 400
finally:
db.conn.close()
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('modelIndex', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[DeleteModel] args: {args}")
modelIndex = args['modelIndex']
token = args['token']
#check user isLogin
if tokenValidator(args['token']):
try:
db = sql()
db.cursor.execute(
f"select * from model where `model_index`='{modelIndex}'")
result = db.cursor.fetchone()
if result[1] != None:
status, resp = ModelService().deleteModel(result[1], token)
if (status):
return {
"status": "success",
"msg": "",
"data": {}
}, 200
else:
return resp
else:
db.cursor.execute(
f"delete from model where `model_index` = '{modelIndex}'"
)
db.conn.commit()
logging.info(f"[DeleteModel] OK with file id {modelIndex}")
return {
"status": "success",
"msg": "can not find model",
"data": {}
}, 200
except Exception as e:
logging.error(str(e))
return {"status": "error", "msg": f"{e}", "data": {}}, 500
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
parser=reqparse.RequestParser()
parser.add_argument('token',type=str,required=True)
parser.add_argument('modelUid',type=str,required=True)
args=parser.parse_args()
if not tokenValidator(args['token']):
return {"status":"error","msg":"token error","data":{}},401
args.pop('token')
logging.info(f'[API_genModelAPI] args:{args}')
mid=args['modelUid']
_,fid,_,_,_,status,_,_=getModelInfo(mid)[0]
if status!='success':
return {"status":"error","msg":"model unready","data":{}},400
APIID=mid+"#"+fid
return {"status":"success","msg":"","data":{"APIId":APIID}}
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('fileID', type=str, required=True)
parser.add_argument('action', type=str, required=True)
parser.add_argument('fileNameAfterProcessing', type=str, required=True)
parser.add_argument('userID', type=str, required=True)
parser.add_argument('projectID', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[DoPreprocess] args: {args}")
fileID = args['fileID']
action = args['action']
token = args['token']
fileNameAfterProcessing = args['fileNameAfterProcessing']
userID = args['userID']
projectID = args['projectID']
#check user isLogin
if tokenValidator(token):
response = AnalyticService().doPreprocess(token, fileID, action)
if response["status"] == "success":
try:
newFileID = response["data"]["fileUid"]
db = sql()
db.cursor.execute(
f"insert into file (`file_id`,`file_name`,`user_id`,`project_id`) values ('{newFileID}','{fileNameAfterProcessing}','{userID}','{projectID}');"
)
db.conn.commit()
logging.info(
f"[DoPreprocess] OK with file uid {newFileID}")
return response
except Exception as e:
db.conn.rollback()
logging.error(str(e))
finally:
db.conn.close()
else:
return response
return response
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
fName='[UploadStudent]'
parser = reqparse.RequestParser()
parser.add_argument('file', type=FileStorage, location='files',required=True)
parser.add_argument('courseID',type=str,required=True)
parser.add_argument('token',type=str,required=True)
args = parser.parse_args()
file = args['file']
courseID = args['courseID']
token=args['token']
#check user isLogin
if tokenValidator(token):
args.pop('token')
logging.debug(f"[UploadStudent] args: {args}")
studentFileTypeList=param.studentFileTypeList
# #check filetype
filename=file.filename
filetype=filename[filename.rfind("."):]
logging.debug(f"[UploadStudent] File type:{filetype}")
if filetype not in studentFileTypeList:
return {"status":"error","msg":"file type error","data":{}},400
# file save
savedPath='./src/student/'+courseID+filetype
try:
file.save(savedPath)
except Exception as e:
return {"status":"error","msg":f"file error:{e}","data":{}},400
try:
fileChecker(savedPath, courseID).studentDataChecker()
randomIndex(savedPath, courseID).randomIndexGenerator()
except Exception as e:
logging.error(f'{fName}{e}')
return {"status":"error","msg":str(e),"data":{}},400
return {"status":"success","msg":"upload success"},200
else:
return {"status":"error","msg":"user did not login","data":{}},401
def get(self):
try:
parser=reqparse.RequestParser()
parser.add_argument('token',type=str,required=True)
parser.add_argument('modelUid',type=str,required=True)
args=parser.parse_args()
if not tokenValidator(args['token']):
return {"status":"error","msg":"token error","data":{}},401
args.pop('token')
logging.debug(f'[API_getModelStatus] args:{args}')
mid=args['modelUid']
_,_,_,_,_,status,_,_=getModelInfo(mid)[0]
return {"status":"success","msg":"","data":status},200
except Exception as e:
logging.error(f"[API_getModelStatus]{traceback.format_exc()}")
return {"status":"error","msg":str(traceback.format_exc()),"data":{}},400
def post(self):
fName = 'API_correlation'
try:
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
parser.add_argument('fileUid', type=str, required=True)
parser.add_argument('algoname', type=str, required=True)
args = parser.parse_args()
fid = args['fileUid']
algoName = args['algoname']
token = args['token']
if not tokenValidator(token):
return {
"status": "error",
"msg": "token error",
"data": {}
}, 401
args.pop('token')
logging.info(f"[{fName}] args: {args}")
module = importlib.import_module(
f"service.analyticService.core.correlationCore.correlationAlgo.{algoName}"
)
algo = getattr(module, algoName)
result = algo(fid).do()
fig = {"div": result['div'], "script": result['script']}
response = make_response(
json.dumps({
'status': 'success',
'msg': '',
'data': fig
}))
response.headers['Access-Control-Allow-Origin'] = '*'
response.headers[
'Access-Control-Allow-Methods'] = 'OPTIONS,HEAD,GET,POST'
response.headers[
'Access-Control-Allow-Headers'] = 'x-requested-with'
return response
except NoDataException as e:
logging.info(f"[{fName}]{e}")
return {"status": "success", "msg": "", "data": "None"}, 200
except Exception as e:
logging.error(f"[{fName}]{traceback.format_exc()}")
return {
"status": "error",
"msg": str(traceback.format_exc()),
"data": {}
}, 400
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('projectID', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[GetProjectInfo] args: {args}")
projectID = args['projectID']
#check user isLogin
if tokenValidator(args['token']):
resp = []
try:
db = sql()
db.cursor.execute(
f"select * from project where `project_id`='{projectID}'")
result = db.cursor.fetchone()
respItem = {
'projectName': result[2],
'projectType': result[3],
'dataType': result[4]
}
except Exception as e:
db.conn.rollback()
return {
"status": "error",
"msg": "project not found",
"data": {}
}, 200
finally:
db.conn.close()
return {
"status": "success",
"msg": "",
"data": {
'project': respItem
}
}, 200
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('userID', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[GetProject] args: {args}")
userID = args['userID']
#check user isLogin
if tokenValidator(args['token']):
resp = []
try:
db = sql()
db.cursor.execute(
f"select * from project where `user_id`='{userID}'")
result = db.cursor.fetchall()
data = [list(a) for a in result]
for item in data:
respItem = {
'projectID': item[0],
'projectName': item[2],
'projectType': item[3],
'dataType': item[4]
}
resp.append(respItem)
except Exception as e:
db.conn.rollback()
finally:
db.conn.close()
logging.debug(f"[GetProject] resp: {resp}")
return {
"status": "success",
"msg": "",
"data": {
'projectList': resp
}
}, 200
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('projectID', type=str, required=True)
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
logging.debug(f"[GetAnalyticsAlgoByProject] args: {args}")
projectID = args['projectID']
token = args['token']
#check user isLogin
if tokenValidator(token):
try:
db = sql()
db.cursor.execute(
f"select * from project where `project_id`='{projectID}'")
result = db.cursor.fetchone()
if result != None:
form = {"dataType": result[4], "projectType": result[3]}
resp = requests.get(coreApi.GetAnalyticAlgo, data=form)
response = resp.json()
logging.warn(f'response {response}')
if response['status'] == 'success':
return response, 200
else:
return response, 400
else:
return {
"status": "error",
"msg": 'Project not found',
"data": {}
}, 400
except Exception as e:
logging.error(str(e))
return {"status": "error", "msg": f'{e}', "data": {}}, 400
db.conn.rollback()
finally:
db.conn.close()
else:
return {
"status": "error",
"msg": "user did not login",
"data": {}
}, 401
