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