def sp_runtest(rule_id, ruleDetailsId) -> JsonResponse: try: logger = get_logger() connection = db_conn() payload = get_sp_payload(ruleDetailsId) if not payload: logger.error("Error in executing stored procedure ") return create_failure(500, 'Error in executing stored procedure', 'Failed') sptable = models.Storedproceduretable.objects.filter( ruledetailsid=ruleDetailsId).values_list('storedprocname') cursor = connection.cursor() for sp in sptable: try: logger.debug("exec digicube_wam.dbo.test_sp" + str(sp[0])) # resultset = cursor.execute("exec "+ str(sp[0])).fetchall() # if not resultset: # return create_failure(500, 'Error in executing stored procedure', 'Failed') except Exception as e: logger.error("Error in executing stored procedure: ", str(e)) return create_failure(500, 'Error in executing stored procedure', 'Failed') cursor.close() connection.close() except Exception as e: logger.error("Error in executing stored procedure: ", str(e)) return create_failure(500, 'Error in executing stored procedure', 'Failed') return create_success('Success')
def api_run_test(rule_id, ruleDetailsId) -> JsonResponse: try: logger = get_logger() payload = get_api_parameter(ruleDetailsId) if not payload: logger.error("Error in run test API") return create_failure(500, 'Error in run test API', 'Failed') api_endpoint = '' except Exception as e: logger.error("Error in run test API: ", str(e)) return create_failure(500, 'Error in run test API', 'Failed') return create_success('success')
def powerbi(self, payload) -> JsonResponse: try: ruleid = payload['ruleid'] ruleid_url = TestClientTemplateMapping.objects.filter(ruleid=ruleid).values_list('url') try: url = ruleid_url[0][0] except Exception as e: self.logger.error("No URL found for selected ruleid: "+str(e)) return create_failure(500, 'No URL found for selected ruleid', 'Failed') except Exception as e: self.logger.error("Error in Powerbi url: "+str(e)) return create_failure(500, 'Error in Powerbi url', 'Failed') return create_success('Success')
def insert_into_db(request,data): try: overwriteMerge = request['Overwrite_merge'] databaseName = request['DatabaseName'] tableName = request['TableName'] except Exception as e: logger.error("Error While Inserting into Database"+str(e)) return create_failure(500, 'Error While Inserting into Database', 'Failed') try: connection = db_conn(databaseName) except Exception as e: logger.error("Error While Creation of Engine "+str(e)) return create_failure(500, 'Error While Creation of Engine', 'Failed') try: try: if(overwriteMerge == "O"): cursor = connection.cursor() cursor.execute('TRUNCATE TABLE {}'.format(tableName)) connection.commit() cursor.close() elif(overwriteMerge != "M"): return False except Exception as e: logger.error("Error While Inserting into DB: "+str(e)) return create_failure(500, 'Error While Inserting into DB ', 'Failed') cursor = connection.cursor() tuples = [tuple(x) for x in data.to_numpy()] cols = "],[".join([str(i) for i in data.columns.tolist()]) databaseChunk = int(config['ENV_VARIABLE']['database_chunk']) chunk = int(len(tuples)/databaseChunk) cursor.fast_executemany = True for i in range(1,chunk+2): try: val = tuples[(i-1)*databaseChunk:i*databaseChunk] query = upload_file_sql_query(tableName,cols,data.columns) cursor.executemany(query,val) except Exception as e: cursor.close() connection.close() logger.error("Error While Inserting into DB "+str(e)) return create_failure(500, 'Error While Inserting into DB', 'Failed') connection.commit() cursor.close() connection.close() logger.info("Success") except Exception as e: logger.error("Error While Inserting into DB "+str(e)) return create_failure(500, 'Error While Inserting into DB', 'Failed') return(create_success('Data Dumped Successfully',''))
def export_class(self,ruleidVar): try: output = {} fileNameList = [] ruleidValue = ruleidVar['RuleID'] self.logger.info(ruleidValue) ruleDetailsObject = Ruledetails.objects.filter(ruleid=ruleidValue) ruleDetailsData = ruledetailsSerializer(ruleDetailsObject, many=True) if(ruleDetailsObject.exists()): try: for ruledetailsRecord in ruleDetailsData.data: try: annexureFileName = ruledetailsRecord['annexurefilename'] if(annexureFileName != None): if(ruleidVar['FileType'].lower() == 'excel'): fileName = annexureFileName + '.xlsx' else: fileName = annexureFileName + '.csv' else: if(ruleidVar['FileType'].lower() == 'excel'): fileName = ruledetailsRecord['ruleid'] + '_' + str(ruledetailsRecord['sequenceno']) + '.xlsx' else: fileName = ruledetailsRecord['ruleid'] + '_' + str(ruledetailsRecord['sequenceno']) + '.csv' self.logger.info(fileName) fileNameList.append(fileName) dbVar = FetchDatabaseName() dbName = dbVar.fetch(ruleidVar['SessionID']) responseCreateFile = self.create_file(ruledetailsRecord,fileName,ruleidVar['FileType'].lower(),ruleidVar['ID'],dbName) if(responseCreateFile != True): return responseCreateFile except Exception as e: self.logger.error("Error in Export Test API during Fetching Ruleid Details from table"+str(e)) return create_failure(500, 'Error in Export Test API during Fetching Ruleid Details from table', 'Failed') except Exception as e: self.logger.error("Error in Export Test API during Fetching Ruleid Details from table"+str(e)) return create_failure(500, 'Error in Export Test API during Fetching Ruleid Details from table', 'Failed') try: output['fileName'] = ','.join(fileNameList) output['appUrl'] = self.appUrl + self.config['ENV_VARIABLE']['download_files'] + ruleidVar['ID'] except Exception as e: self.logger.error("Error in Export Test API during creation of output"+str(e)) return create_failure(500, 'Error in Export Test API during creation of output', 'Failed') except Exception as e: self.logger.error("Error in Export Test API "+str(e)) return create_failure(500, 'API Fail due to Exception', 'Failed') return create_success("Export API is Working",output)
def dump_file(request): try: fileType = request['FileType'] if(fileType.lower() == "csv"): status,dataParse,tableSchema = parse_csv_file(request) elif(fileType.lower() == 'excel'): status,dataParse,tableSchema = parse_excel_file(request) if(status == True): dataUpdated = validate_record(request,dataParse,tableSchema) if(dataUpdated is False): return create_failure(500, 'Data Type of Records is not valid', 'Failed') response = insert_into_db(request,dataUpdated) return response except Exception as e: logger.error("Error While Dumping File"+str(e)) return create_failure(500, 'Error Wile Dumping File', 'Failed') return status
def post(self, request: Request) -> JsonResponse: try: token = verify_jwt_token(request.META['HTTP_AUTHORIZATION']) if (token == 0): self.logger.error("Error in Upload File Import API token: ") return JsonResponse( create_failure(400, 'Invalid token', 'Fail')) except Exception as e: self.logger.error("Error in Authentication." + str(e)) return JsonResponse( create_failure_modified(500, 'Authentication Error', 'Failed', '', 'failed')) try: self.uniqueID = request.data['uniqueID'] except Exception as e: self.logger.error("Please provide uniqueid " + str(e)) return JsonResponse( create_failure_modified(500, 'Please provide uniqueid', 'Failed', '', 'failed')) try: self.fileName = request.data['fileName'] except Exception as e: self.logger.error("Error in FileName " + str(e)) return JsonResponse( create_failure_modified(500, 'Error in FileName ', 'Failed', '', 'failed')) try: if (not request.data['file']): return JsonResponse( create_failure_modified(500, 'Failed to Upload File', 'Failed', '', 'failed')) elif (len(self.uniqueID.strip()) == 0): return JsonResponse( create_failure_modified(500, 'Failed to Upload File', 'Failed', '', 'failed')) else: if (self.save_file(request) != True): return JsonResponse( create_failure_modified(500, 'File is Corrupted', 'Failed', '', 'failed')) if (self.fileName.split('.')[-1] == "csv"): response = self.read_csv_file(request) elif (self.fileName.split('.')[-1] == 'xlsx'): response = self.read_excel_file(request) else: JsonResponse( create_failure_modified( 500, 'Invalid file type , Please upload Excel or CSV file', 'Failed', '', 'failed')) except Exception as e: self.logger.error("Error in API" + str(e)) return JsonResponse( create_failure_modified(500, 'API Fail due to Exception', 'Failed', '', 'failed')) return JsonResponse(response)
def post(self, request: Request) -> JsonResponse: try: token = verify_jwt_token(request.META['HTTP_AUTHORIZATION']) if token == 0: self.logger.error("Error in Delete API token: ") return JsonResponse( create_failure(400, 'Invalid token', 'Failed')) except Exception as e: self.logger.error("Error in Authentication Delete API." + str(e)) return JsonResponse( create_failure(500, 'Authentication Error', 'Failed')) try: response = self.main_function(request) return JsonResponse(response) except Exception as e: self.logger.error("Error in Delete API " + str(e)) return JsonResponse( create_failure(500, 'API Fail due to Exception', 'Failed'))
def main_function(self, request): try: ########## Excel File Delete ########## try: excelFileRoot = self.config['ENV_VARIABLE']['file_path'] res = self.file_path_creation(request, excelFileRoot) if (res == False): create_failure(500, "API Fail due to Exception", "Failed") except Exception as e: self.logger.error("Error in Delete API " + str(e)) return JsonResponse( create_failure(500, "API Fail due to Exception", "Failed")) ########## Zip File Delete ########## try: zipFileRoot = self.config['ENV_VARIABLE']['file_path_zip'] res = self.file_path_creation(request, zipFileRoot) if (res == False): create_failure(500, "API Fail due to Exception", "Failed") except Exception as e: self.logger.error("Error in Delete API " + str(e)) return JsonResponse( create_failure(500, "API Fail due to Exception", "Failed")) ########## Download File Delete ########## try: downloadFileRoot = self.config['ENV_VARIABLE'][ 'file_path_download'] res = self.file_path_creation(request, downloadFileRoot) if (res == False): create_failure(500, "API Fail due to Exception", "Failed") except Exception as e: self.logger.error("Error in Delete API " + str(e)) return JsonResponse( create_failure(500, "API Fail due to Exception", "Failed")) return create_success('File Deleted Successfully', 'Deleted') except Exception as e: self.logger.error("Error in Delete API " + str(e)) return JsonResponse( create_failure(500, "API Fail due to Exception", "Failed"))
def parse_excel_file(request): try: filePath = request['FilePath'] sheetName = request['SheetName'] except Exception as e: logger.error("Error While Fetching Request Data"+str(e)) return create_failure(500, 'Error While Fetching Request Data', 'Failed') try: data = pd.read_excel(open(filePath, 'rb'),sheet_name=sheetName) data.replace({pd.NaT: None}, inplace=True) data.replace({pd.NA: None}, inplace=True) data.replace({np.nan: None}, inplace=True) tableMapping = table_column_mapping(request) if(tableMapping is False): return create_failure(500, 'Error while Mapping File Columns to Table Columns', 'Failed') dataParse = data.rename(columns=tableMapping) tableSchema = fetch_schema(request,data) if(tableSchema is False): return create_failure(500, 'Error While Fetching Schema of table', 'Failed') except Exception as e: logger.error("Error While Processing Excel File "+str(e)) return create_failure(500, 'Error While Processing Excel File', 'Failed') return (True,dataParse,tableSchema)
def post(self, request: Request) -> JsonResponse: """ :param request: Client request containing request information :return: """ try: emailid = request.data['email'] user_password = request.data['password'] except Exception as e: self.logger.error("Error in email address or password." + str(e)) return JsonResponse(create_failure(500, 'Value Missing', 'Fail')) if len(emailid) < 1: self.logger.error("Error in email address.") return JsonResponse( create_failure(401, 'Incorrect Email Address', 'Fail')) try: userInfo = Userlogindetails.objects.get(emailaddress=emailid) except Exception as e: self.logger.error("Error in Email Address." + str(e)) return JsonResponse(create_failure(401, 'Email not found', 'Fail')) try: if str(userInfo.password) == (user_password): try: jwtToken = make_jwt_token(data={'userid': userInfo.id}) outputDict = { 'Email': userInfo.emailaddress, 'Password': userInfo.password, 'UserID': userInfo.id, 'Token': jwtToken } output = create_success('Authorization Successful!', outputDict) except Exception as e: self.logger.error( "Error while connecting to POST API of Login Module." + str(e)) return JsonResponse( create_failure(401, 'Authorization Failed', 'Fail')) else: return JsonResponse( create_failure(401, 'Incorrect Password', 'Fail')) except Exception as e: self.logger.error( "Error while connecting to POST API of Login Module." + str(e)) return JsonResponse( create_failure(401, 'Authorization Failed', 'Fail')) return JsonResponse(output)
def run_test_function(self, payload) -> JsonResponse: try: rule_id = payload['RuleID'] session_id = payload['SessionID'] toDoList_id = payload['ToDoListID'] user_id = payload['UserID'] except Exception as e: self.logger.error("Error in fetching data from db : "+str(e)) return JsonResponse(create_failure(500, 'Please provide valid key', 'Fail')) try: todayDate = datetime.datetime.now() testdetails = Ruledetails.objects.filter(ruleid=rule_id).values_list('ruletype','resultquery','ruledetailsid') if testdetails.exists(): for testdetailsitems in testdetails: try: # create mapping table entry sessionTestId = uuid.uuid4() mappingsessiontest = models.Sessiontestmapping(sessiontestid = sessionTestId, userid = user_id, sessionid = session_id, todolistid = toDoList_id, ruleid = rule_id, createddate = todayDate, ruledetailsid = testdetailsitems[2]) mappingsessiontest.save() if str(testdetailsitems[0]) == "sp_query": resSP = sp_runtest(rule_id, testdetailsitems[2]) if resSP['statusCode'] == 200: return create_success('Success') else: return create_failure(500, 'Failed to execute Stored Procedure', 'Failed') elif str(testdetailsitems[0]) == "api": resapi = api_run_test(rule_id, testdetailsitems[2]) if resapi['statusCode'] == 200: return create_success('Success') else: return create_failure(500, 'Failed to execute Stored Procedure', 'Failed') except Exception as e: self.logger.error("Error in parsing ruledetails table: "+str(e)) return create_failure(500, 'Error in parsing ruledetails table', 'Failed') else: return create_failure(500, 'No data for seleted Rule Id', 'Failed') self.connection.close() except Exception as e: self.logger.error("Error in fetching the tests: "+str(e)) return create_failure(500, 'Error in parsing ruledetails table', 'Failed') return create_success('Success')
def post(self, request:Request) -> JsonResponse: try: userid = verify_jwt_token(request.META['HTTP_AUTHORIZATION']) if userid == 0: self.logger.error("Error in View Results API token: ") return JsonResponse(create_failure(400, 'Invalid token', 'Fail')) except Exception as e: self.logger.error("Error in View Results API: "+str(e)) return JsonResponse(create_failure(400, 'Please provide valid token', 'Fail')) try: session_id = request.data['SessionID'] except Exception as e: self.logger.error("invalid SessionID"+str(e)) return JsonResponse(create_failure(400, 'invalid SessionID', 'Fail')) try: resultset = [] testdetails = Sessiontestmapping.objects.filter(userid=userid, sessionid=session_id).values_list('ruledetailsid', 'todolistid','ruleid','createddate') if testdetails.exists(): for mappingitems in testdetails: resultdict = {} try: ruledetails = dashboardModels.Ruledetails.objects.filter(ruledetailsid=mappingitems[0]).values_list('shortdescription') for ruledetailsitem in ruledetails: resultdict['ShortDescription'] = ruledetailsitem[0] rulemaster = dashboardModels.Rulemaster.objects.filter(rulemasterid=mappingitems[2]).values_list('testno', 'testname') resultdict['TestNo'] = rulemaster[0][0] resultdict['TestName'] = rulemaster[0][1] todoliststatus = Todolist.objects.filter(id=mappingitems[1]).values_list('status') resultdict['Status'] = todoliststatus[0][0] resultdict['CreatedDate'] = mappingitems[3] resultdict['RuleId'] = mappingitems[2] resultset.append(resultdict) except Exception as e: self.logger.error("Occured error while fetching list of Results: "+str(e)) return JsonResponse(create_failure(400, 'Invalid SessionID', 'Fail')) else: return JsonResponse(create_failure(500, 'No Records Found', 'Fail')) except Exception as e: self.logger.error("Occured error while fetching list of Results: "+str(e)) return JsonResponse(create_failure(400, 'Bad Request', 'Fail')) return JsonResponse(create_success('success', resultset))
def post(self, request: Request) -> JsonResponse: try: userid = verify_jwt_token(request.META['HTTP_AUTHORIZATION']) if userid == 0: self.logger.error("Error in Publish Message API token: ") return JsonResponse( create_failure(400, 'Invalid token', 'Fail')) except Exception as e: self.logger.error("Error in Publish Message API: " + str(e)) return JsonResponse( create_failure(400, 'Please provide valid token', 'Fail')) try: #for send email! sendMailFlag = False attachFilepath = [] # To insert record into ToDoList table for requestDataVar in request.data: try: statusInsert = self.insert_todo_list(requestDataVar) # for Run-Test API if (self.eventType == 'TestExec'): try: # TODO: implement messageQueue and scheduler payload = { "RuleID": requestDataVar['RuleID'], "SessionID": requestDataVar['SessionID'], "ToDoListID": requestDataVar['ID'], "UserID": userid } runTest = run_test_api() responseRuntest = runTest.run_test_function( payload) if responseRuntest['statusCode'] == 200: self.update_todo_list(request, "Success") else: self.update_todo_list( request, responseRuntest['replyCode'], responseRuntest['message']) except Exception as e: self.logger.error( "Error in run test execution API: " + str(e)) self.update_todo_list(request, "Failed", str(e)) # For Upload file functionality elif (self.eventType == 'Import'): try: dbVar = FetchDatabaseName() dbName = dbVar.fetch(self.sessionId) if (len(dbName) != 0): try: if (self.fileType == 'CSV'): payload = { "FileType": self.fileType, "ClientID": self.clientId, "FilePath": self.filePath, "SheetName": self.sheetName, "Overwrite_merge": self.overWriteMerge, "DatabaseName": dbName, "TableName": self.tableName, "textqualifier": self.textQualifier, "rowdelimeter": self.rowDelimeter, "columndelimeter": self.columnDelimeter, "numberRowToSkip": self.numberRowToSkip, "iscolumnnameinfirstrow": self.isColumnNameInFirstRow } else: payload = { "FileType": self.fileType, "ClientID": self.clientId, "FilePath": self.filePath, "SheetName": self.sheetName, "Overwrite_merge": self.overWriteMerge, "DatabaseName": dbName, "TableName": self.tableName } resUpload = dump_file(payload) if (resUpload['statusCode'] == 200): self.update_todo_list( request, "Success") else: self.logger.info( "Response DumpFile- {}".format( resUpload)) self.update_todo_list( request, "Failed", resUpload['message']) except Exception as e: self.logger.error("Error in DumpFile: " + str(e)) self.update_todo_list( request, "Failed", str(e)) else: self.logger.info( "Response FetchDB- {}".format(dbName)) self.update_todo_list(request, "Failed", dbName['message']) except Exception as e: self.logger.error("Error in FetchDB: " + str(e)) self.update_todo_list(request, "Failed", str(e)) # For Export test output file elif (self.eventType == 'Output'): try: classVar = export_test() resExport = classVar.export_class(requestDataVar) if (resExport['statusCode'] == 200): self.fileName = resExport['data']['fileName'] self.appUrl = resExport['data']['appUrl'] self.update_todo_list(request, "Success", 'Output') else: self.logger.error( "Response Export- {}".format(resExport)) self.update_todo_list(request, "Failed", resExport['message']) except Exception as e: self.logger.error("Error in Export Test: " + str(e)) self.update_todo_list(request, "Failed", str(e)) # for sending Email elif (self.eventType == 'Email'): try: classVar = export_test( ) #using export function to attaching files in Email resExport = classVar.export_class(requestDataVar) if (resExport['statusCode'] == 200): self.fileName = resExport['data']['fileName'] self.outputPublishFolderPath = self.config[ 'ENV_VARIABLE'][ 'file_path_download'] + requestDataVar[ 'ID'] self.appUrl = resExport['data']['appUrl'] self.update_todo_list(request, "Success", 'Output') attachFilepath.append( str(self.outputPublishFolderPath) + "/" + str(self.fileName)) print(attachFilepath) try: emailIds = requestDataVar[ 'To'] # stroing email from request pyaload emailIds = emailIds.split( ';' ) # spliting emails from string to List emailIds = [ x.strip(' ') for x in emailIds ] # storing email ids without white spaces sendMailFlag = True # to confirm for sending email except Exception as e: self.logger.error( "Error In Fething Emails", str(e)) else: self.logger.error( "Response Export- {}".format(resExport)) self.update_todo_list(request, "Failed", resExport['message']) except Exception as e: self.logger.error( "Error in Export Test for sending email: " + str(e)) self.update_todo_list(request, "Failed", str(e)) # For creating New Session elif (self.eventType == 'NewSession'): try: #TODO: Implement scheduler and messageQueue payload = { "ClientID": requestDataVar['ClientID'], "SessionID": requestDataVar['SessionID'], "AuditFrom": requestDataVar['AuditFrom'], "AuditTo": requestDataVar['AuditTo'], "ProjectName": requestDataVar['ProjectName'], "SerialNo": requestDataVar['SerialNo'], "userid": userid } newSess = new_session() responseNewSess = newSess.post(payload) if responseNewSess['statusCode'] == 200: self.update_todo_list(request, "Success") else: self.update_todo_list( request, responseNewSess['replyCode'], responseNewSess['message']) except Exception as e: self.logger.error("Error in new session API: " + str(e)) self.update_todo_list(request, "Failed", str(e)) # For Power BI URL Validity elif (self.eventType == 'ViewInPowerBI'): try: payload = {"ruleid": requestDataVar['RuleID']} powerbi_func = powerbi_url() response_powerbi = powerbi_func.powerbi(payload) if response_powerbi['statusCode'] == 200: self.update_todo_list(request, "Success") else: self.update_todo_list( request, response_powerbi['replyCode'], response_powerbi['message']) except Exception as e: self.logger.error("Error in powerbi url API: " + str(e)) self.update_todo_list(request, "Failed", str(e)) except Exception as e: self.logger.error("Error in Publish Message API: " + str(e)) return JsonResponse( create_failure(400, 'Error in Publish Message API', 'Fail')) if sendMailFlag: #if true mail will be send self.send_email(attachFilepath, emailIds) #calling send_email Function except Exception as e: self.logger.error("Error in publish_message API: " + str(e)) return JsonResponse( create_failure(500, 'Error in publish_message API', 'Fail')) return JsonResponse(create_success('Success', ''))
def post(self, request: Request) -> JsonResponse: try: userid = verify_jwt_token(request.META['HTTP_AUTHORIZATION']) if userid == 0: self.logger.error("Error in changePassword API token: ") return JsonResponse( create_failure(400, 'invalid Token', 'Fail')) except Exception as e: self.logger.error("Error in changePassword API: " + str(e)) return JsonResponse( create_failure(400, 'Please provide valid Token', 'Fail')) try: email = request.data['email'] if not email: self.logger.error("invalid email") return JsonResponse( create_failure(400, 'provide valid email', 'Fail')) except Exception as e: self.logger.error("invalid email" + str(e)) return JsonResponse(create_failure(400, 'provide email', 'Fail')) try: oldPassword = request.data['old_password'] if not oldPassword: self.logger.error("invalid password") return JsonResponse( create_failure(400, 'provide valid old password', 'Fail')) userInfo = Userlogindetails.objects.get(emailaddress=email) self.logger.info(userInfo.password) if userInfo.password != (oldPassword): self.logger.error("invalid password") return JsonResponse( create_failure(400, 'invalid old password', 'Fail')) except Exception as e: self.logger.error("invalid password." + str(e)) return JsonResponse( create_failure(400, 'provide valid old password', 'Fail')) try: newPassword = request.data['new_password'] if not newPassword: self.logger.error("invalid new password") return JsonResponse( create_failure(400, 'provide valid new password', 'Fail')) except Exception as e: self.logger.error("invalid new password" + str(e)) return JsonResponse( create_failure(400, 'provide valid new password', 'Fail')) try: if newPassword == oldPassword: self.logger.error( "old password and new password should not be same") return JsonResponse( create_failure( 400, 'old password and new password should not be same', 'Fail')) except Exception as e: self.logger.error( "old password and new password should not be same" + str(e)) return JsonResponse( create_failure( 400, 'old password and new password should not be same', 'Fail')) try: currentTime = timezone.now() UserlogindetailsUpdate = Userlogindetails.objects.filter( emailaddress=email).update(password=newPassword, modifieddate=currentTime) if UserlogindetailsUpdate == 0: return JsonResponse( create_failure(204, 'Failed to update password', 'Fail')) except Exception as e: self.logger.error("invalid email" + str(e)) return JsonResponse( create_failure(500, 'Failed to update password', 'Fail')) return JsonResponse( create_success("Password Updated Successfully!", []))
def post(self,request : Request) -> JsonResponse: try: token = verify_jwt_token(request.META['HTTP_AUTHORIZATION']) if token == 0: self.logger.error("Error in Download API token: ") return JsonResponse(create_failure(400, 'Invalid token', 'Failed')) except Exception as e: self.logger.error("Error in Download API."+str(e)) return JsonResponse(create_failure(500, 'Authentication Error', 'Failed')) try: toDoListID = request.data['toDoListID'] zipFilePath = self.config['ENV_VARIABLE']['file_path_zip'] downloadFilePath = self.config['ENV_VARIABLE']['file_path_download'] if not os.path.exists(zipFilePath): os.makedirs(zipFilePath) try: settingsObject = Settings.objects.all() settingsData = settingsSerializer(settingsObject, many=True) if(settingsData.data): try: appUrl = settingsData.data[0]['appurl'] self.zipCount = settingsData.data[0]['layercount'] except Exception as e: self.logger.error("Failed to convert files into zip "+str(e)) return JsonResponse(create_failure(500, 'Failed to convert files into zip - Error in Settings Table', 'Failed')) else: self.logger.error("Failed to convert files into zip - Error in Settings Table "+str(e)) return JsonResponse(create_failure(500, 'Failed to convert files into zip - Error in Settings Table', 'Failed')) except Exception as e: self.logger.error("Failed to convert files into zip "+str(e)) return JsonResponse(create_failure(500, 'Failed to convert files into zip - Error in Settings Table', 'Failed')) urlList = [] filePathList = [] for toDoID in toDoListID: try: toDoListObject = Todolist.objects.filter(id=toDoID) todoListData = todolistSerializer(toDoListObject, many=True) if(todoListData.data): try: fileName = todoListData.data[0]['outputfilename'] fileList = fileName.split(',') for files in fileList: urlJson = dict() url = appUrl + self.config['ENV_VARIABLE']['download_files'] + toDoID + '/' + files urlJson['ID'] = toDoID urlJson['DownloadUrl'] = url urlJson['Zip'] = False urlList.append(urlJson) filePath = toDoID + '/' + files filePathList.append(filePath) except Exception as e: self.logger.error("Failed to Fetch Output file name - Error in Todolist Table "+str(e)) return JsonResponse(create_failure(500, 'Failed to Fetch Output file name - Error in Todolist Table ', 'Failed')) except Exception as e: self.logger.error("Failed to Fetch Output file name - Error in Todolist Table "+str(e)) return JsonResponse(create_failure(500, 'Failed to Fetch Output file name - Error in Todolist Table ', 'Failed')) if(len(filePathList) >= self.zipCount): compression = zipfile.ZIP_DEFLATED now = datetime.datetime.now() timeStamp = datetime.datetime.timestamp(now) zipfileName = zipFilePath + str(timeStamp) + ".zip" zipFiles = zipfile.ZipFile(zipfileName, mode="w") for files in filePathList: try: fileName = files.split("/")[-1] filesVar = downloadFilePath + files zipFiles.write(filesVar, fileName, compress_type=compression) except Exception as e: self.logger.error("Failed to convert files into zip"+str(e)) return JsonResponse(create_failure(500, 'Failed to convert files into zip', 'Failed')) zipFiles.close() zipUrl = appUrl + self.config['ENV_VARIABLE']['zip_files'] + str(timeStamp) + '.zip' for i in range(len(urlList)): urlList[i]['DownloadUrl'] = zipUrl urlList[i]['Zip'] = True output = {'DownloadURL' : urlList} except Exception as e: self.logger.error("Failed to convert files into zip "+str(e)) return JsonResponse(create_failure(500, 'Failed to convert files into zip', 'Failed')) return JsonResponse(create_success('URL Generated Successfully',output ))
def create_file(self,ruledetailsRecord,fileName,fileType,todoId,dbName): try: settingsObject = Settings.objects.all() settingsData = settingsSerializer(settingsObject, many=True) if(settingsData.data): try: filePath = settingsData.data[0]['outputrootdirectory'] self.appUrl = settingsData.data[0]['appurl'] except Exception as e: self.logger.error("Error in Settings Table "+str(e)) return create_failure(500, 'Error in Settings Table', 'Failed') else: self.logger.error("Error in Settings Table "+str(e)) return create_failure(500, 'Error in Settings Table', 'Failed') try: self.connection = db_conn(dbName) cursor = self.connection.cursor() except Exception as e: self.logger.error("Error while Creating Database Connection: "+str(e)) return create_failure(500, 'Error while Creating Database Connection', 'Failed') directory = filePath + '/' + todoId if not os.path.exists(directory): os.makedirs(directory) try: resultset = cursor.execute(ruledetailsRecord['resultquery']).fetchall() fieldName = [field[0] for field in cursor.description] cursor.close() self.connection.close() dateColumns = [] dateFlag = False # For finding date time object for i in range(len(resultset[0])): try: if(type(resultset[0][i]) == datetime.datetime): dateColumns.append(i) dateFlag = True except Exception as e: self.logger.error("Error while Handling DateObjects "+str(e)) return create_failure(500, 'Error while Handling DateObjects', 'Failed') except Exception as e: self.logger.error("Error while Fetching Table Data: "+str(e)) return create_failure(500, 'Error while Fetching Table Data', 'Failed') if(fileType == 'excel'): with xlsxwriter.Workbook(directory+ '/' + fileName) as workbook: try: worksheet = workbook.add_worksheet() for colNum, data in enumerate(fieldName): try: worksheet.write(0, colNum, data) except Exception as e: self.logger.error("Error while writing in Excel File "+str(e)) return create_failure(500, 'Error while writing in Excel File', 'Failed') for rowNum, data in enumerate(resultset): try: if(dateFlag == True): for i in dateColumns: data[i] = str(data[i]) worksheet.write_row(rowNum+1, 0, data) except Exception as e: self.logger.error("Error while writing in Excel File "+str(e)) return create_failure(500, 'Error while writing in Excel File', 'Failed') except Exception as e: self.logger.error("Error while writing in Excel File "+str(e)) return create_failure(500, 'Error while writing in Excel File', 'Failed') else: with open(directory+ '/' + fileName, 'w', newline='') as file: try: csvWriter = csv.writer(file) csvWriter.writerow(fieldName) for rowNum, data in enumerate(resultset): if(dateFlag == True): for i in dateColumns: data[i] = str(data[i]) csvWriter.writerow(data) except Exception as e: self.logger.error("Error while writing in CSV File "+str(e)) return create_failure(500, 'Error while writing in CSV File', 'Failed') except Exception as e: self.logger.error("Error in fetching the tests: "+str(e)) return create_failure(500, 'Error in fetching the tests', 'Fail') return True
def post(self, payload) -> JsonResponse: try: client_id = payload['ClientID'] except Exception as e: self.logger.error("invalid clientID"+str(e)) return create_failure(400, 'provide ClientID', 'Fail') try: session_id = payload['SessionID'] except Exception as e: self.logger.error("invalid SessionID"+str(e)) return create_failure(400, 'provide SessionID', 'Fail') try: AuditFrom = payload['AuditFrom'] except Exception as e: self.logger.error("invalid AuditFrom "+str(e)) return create_failure(400, 'provide AuditFrom', 'Fail') try: AuditTo = payload['AuditTo'] except Exception as e: self.logger.error("invalid AuditTo "+str(e)) return create_failure(400, 'provide AuditTo', 'Fail') try: ProjectName = payload['ProjectName'] except Exception as e: self.logger.error("invalid ProjectName "+str(e)) return create_failure(400, 'provide ProjectName', 'Fail') try: serialno = payload['SerialNo'] except Exception as e: self.logger.error("invalid serialno "+str(e)) return create_failure(400, 'provide serialno', 'Fail') try: userid = payload['userid'] except Exception as e: self.logger.error("invalid userid "+str(e)) return create_failure(400, 'provide valid token', 'Fail') try: # Step- I Create new database) try: self.databaseName = datetime.datetime.now().strftime("%B%d%Y%H%M%S") self.logger.debug("db name :"+ str(self.databaseName)) self.connection = db_conn() self.connection.autocommit = True cursor = self.connection.cursor() db_create = cursor.execute("create database "+str(self.databaseName)) cursor.close() self.connection.close() create_db = self.create_database() except Exception as e: self.logger.error("error in creating db: "+str(e)) return create_failure(400, 'Error in creating database', 'Fail') #STEP-II: insert record in Tbl_m_databases table try: self.tbldbSettingsId = str(uuid.uuid4()) password = self.config['DIGICUBEDB']['password'] self.logger.debug("tbldbSettingsId: "+ str(self.tbldbSettingsId)) self.connection = db_conn() self.connection.autocommit = True cursor = self.connection.cursor() insertIntoTable = cursor.execute(insert_record_in_tbl_m_database_table(self.tbldbSettingsId,self.databaseName,'SQL',self.server,self.username,'1',str(self.todaydate),password)) cursor.close() self.connection.close() except Exception as e: self.logger.error("Error in Tbl_m_databasessettings table: "+str(e)) self.connection = db_conn() self.connection.autocommit = True cursor = self.connection.cursor() db_drop = cursor.execute("drop database "+str(self.databaseName)) cursor.close() self.connection.close() return create_failure(400, 'Error in creating Tbl_m_databasessettings table', 'Fail') # Step-III: Insert new record in session main table try: clientCode = '' sessionNum = result_str = ''.join(random.choice(string.ascii_letters) for i in range(10)) sessionMainId = uuid.uuid4() self.logger.debug("sessionMainId: "+ str(sessionMainId)) clientCodelist = dashboardModels.Clientmaster.objects.filter(clientmasterid=client_id).values_list("clientcode") for item in clientCodelist: clientCode = item[0] self.sessionMainTbl = dashboardModels.Sessionmain(sessionmainid=sessionMainId, clientid=client_id, dbid=self.tbldbSettingsId, sessionstartdate=self.todaydate, createddate=self.todaydate, auditfrom=AuditFrom, auditto=AuditTo, projectname=ProjectName, serialno=serialno, sessionno=sessionNum, clientcode=clientCode, userid=userid) self.sessionMainTbl.save() except Exception as e: self.logger.error("Error in creating sessionMainTbl: "+str(e)) self.connection = db_conn() self.connection.autocommit = True cursor = self.connection.cursor() db_drop = cursor.execute("drop database "+str(self.databaseName)) deleteFromTable = cursor.execute("DELETE FROM tbl_m_DatabaseSettings WHERE ID='"+self.tbldbSettingsId+"' ") cursor.close() self.connection.close() return create_failure(400, 'Error in creating sessionMainTbl', 'Fail') #Step - IV : update client master table try: clientMaster = dashboardModels.Clientmaster.objects.get(clientmasterid=client_id) clientMaster.sessionid = self.sessionMainTbl.sessionmainid clientMaster.save() except Exception as e: self.logger.error("Error in creating sessionMainTbl: "+str(e)) self.connection = db_conn() self.connection.autocommit = True cursor = self.connection.cursor() db_drop = cursor.execute("drop database "+str(self.databaseName)) deleteFromTable = cursor.execute("DELETE FROM tbl_m_DatabaseSettings WHERE ID='"+self.tbldbSettingsId+"' ") cursor.close() self.connection.close() self.sessionMainTbl.delete() return create_failure(400, 'Error in creating sessionMainTbl', 'Fail') except Exception as e: self.logger.error("Error in new_session API: "+str(e)) return create_failure(400, 'new_session API Fail', 'Fail') return create_success('success')
def parse_csv_file(request): try: filePath = request['FilePath'] except Exception as e: logger.error("Error While Fetching File Path"+str(e)) return create_failure(500, 'Error While Fetching File Path', 'Failed') try: textQual = request['textqualifier'] if(len(textQual) == 0): textQual = ' ' except Exception as e: logger.error("Error While Fetching TextQualifier "+str(e)) return create_failure(500, 'Error While Fetching TextQualifier', 'Failed') try: rowDel = base64.b64decode(request['rowdelimeter']).decode("utf-8") except Exception as e: logger.error("Error While Fetching Row Delimeter"+str(e)) return create_failure(500, 'Error While Fetching Row Delimeter', 'Failed') try: colDel = base64.b64decode(request['columndelimeter']).decode("utf-8") except Exception as e: logger.error("Error While Fetching Column Delimeter"+str(e)) return create_failure(500, 'Error While Fetching Column Delimeter', 'Failed') try: noRowToSkip = int(request['numberRowToSkip']) except Exception as e: logger.error("Error While Fetching Number of Rows to Skip"+str(e)) return create_failure(500, 'Error While Fetching Number of Rows to Skip', 'Failed') try: firstRowHeader = request['iscolumnnameinfirstrow'] if(firstRowHeader == 'true'): firstRowHeader = 0 else: firstRowHeader = None except Exception as e: logger.error("Error While Fetching Is ColumnName in First Row "+str(e)) return create_failure(500, 'Error While Fetching Is ColumnName in First Row ', 'Failed') try: with open(filePath) as csv_data: data = csv_data.read() if(len(textQual) != 1): data = data.replace(textQual,"'") textQual = "'" except Exception as e: logger.error("Error While Processing CSV File "+str(e)) return create_failure(500, 'Error While Processing CSV File', 'Failed') try: if(rowDel == '/r/n' or rowDel == '//r//n' or rowDel == '\\r\\n' or rowDel == '\r\n'): data = pd.read_csv(io.StringIO(data),encoding='ISO-8859-1',sep=colDel,header=firstRowHeader,skiprows=noRowToSkip,quotechar=textQual) elif(rowDel == '/n'): data = pd.read_csv(io.StringIO(data),encoding='ISO-8859-1',sep=colDel,lineterminator='\n',header=firstRowHeader,skiprows=noRowToSkip,quotechar=textQual) elif(rowDel == '/r'): data = pd.read_csv(io.StringIO(data),encoding='ISO-8859-1',sep=colDel,lineterminator='\r',header=firstRowHeader,skiprows=noRowToSkip,quotechar=textQual) else: data = pd.read_csv(io.StringIO(data),encoding='ISO-8859-1',sep=colDel,lineterminator=rowDel,header=firstRowHeader,skiprows=noRowToSkip,quotechar=textQual) data.replace({pd.NaT: None}, inplace=True) data.replace({pd.NA: None}, inplace=True) tableMapping = table_column_mapping(request) if(tableMapping is False): return create_failure(500, 'Error while Mapping File Columns to Table Columns', 'Failed') dataParse = data.rename(columns=tableMapping) tableSchema = fetch_schema(request,data) if(tableSchema is False): return create_failure(500, 'Error While Fetching Schema of table', 'Failed') except Exception as e: logger.error("Error While Processing CSV File "+str(e)) return create_failure(500, 'Error While Processing CSV File', 'Failed') return (True,dataParse,tableSchema)
def post(self, request): try: token = verify_jwt_token(request.META['HTTP_AUTHORIZATION']) if token == 0: self.logger.error("Error in Upload File Import API token: ") return JsonResponse( create_failure(400, 'Invalid token', 'Fail')) except Exception as e: self.logger.error("Error in Fetching Data." + str(e)) return JsonResponse( create_failure_modified(500, 'Data Request Error', 'Failed', '', 'failed')) try: toDoID = request.data['toDoID'] try: toDoCount = Todolist.objects.filter(id=toDoID).count() if (toDoCount == 0): return JsonResponse( create_failure_modified(500, 'No Entry in DB', 'Failed', '', 'failed')) else: toDo = Todolist.objects.get(id=toDoID) toDoVal = list(Todolist.objects.filter(id=toDoID).values()) if (toDo.status == 'Pending'): trigger_event(toDoID) if (data['status'] == 'success'): res = self.response_filter(data['data'][0]) data['data'][0] = res return JsonResponse( create_success(data['message'], data['data'])) else: res = self.response_filter(data['data'][0]) data['data'][0] = res return JsonResponse( create_failure_modified( 500, data['message'], 'Fail', data['data'])) elif (toDo.status == 'Failed'): toDoVal[0] = self.response_filter(toDoVal[0]) return JsonResponse( create_failure_modified(500, 'fetched failed status', 'Fail', toDoVal)) else: toDoVal[0] = self.response_filter(toDoVal[0]) return JsonResponse( create_success('fetched success status', toDoVal)) if (data['status'] == 'success'): res = self.response_filter(data['data'][0]) data['data'][0] = res return JsonResponse( create_success_modified(data['message'], data['data'])) else: res = self.response_filter(data['data'][0]) data['data'][0] = res return JsonResponse( create_failure_modified(500, data['message'], 'Fail', data['data'])) except Exception as e: self.logger.error("Bad Request." + str(e)) return JsonResponse( create_failure_modified(500, 'Bad Request', 'Fail')) except Exception as e: self.logger.error("Value Missing." + str(e)) return JsonResponse( create_failure_modified(500, 'Value Missing', 'Fail'))