def testDBError(self):
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_write_data_topic')
if (not serv_topic):
rospy.logerror(
"rapp_mysql_wrapper_user_write_data_topic NOT FOUND ERROR")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, writeDataSrv)
req = writeDataSrv()
req.req_cols = [
] #[String(data="model_str"),String(data="manufacturer"),String(data="version"),String(data="arch"),String(data="os"),String(data="picture")]
#req.req_cols=[String("id"),String("macddr"), String("model"),String("owner"), String("timestamp")]
req.req_cols = ["idsd", "macddr", "model", "owner", "timestamp"]
entry1 = StringArrayMsg()
#entry1=[string("'3'"),string("'1800000'"), string("'1'"),string("'1'"), string("'2014-11-23 09:04:13'")]
entry1 = ["'3'", "'1800000'", "'1'", "'25'", "'2014-11-23 09:04:13'"]
entry2 = StringArrayMsg()
#entry2=[string("'4'"),string("'1900000'"), string("'1'"),string("'1'"), string("'2014-11-23 07:04:13'")]
entry2 = ["'4'", "'1900000'", "'1'", "'25'", "'2014-11-23 07:04:13'"]
req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)]
response = db_service(req.req_cols, req.req_data)
self.assertEqual(
response.trace[0],
"Database Error 1054: Unknown column 'idsd' in 'field list'")
self.assertFalse(response.success.data)
def speech_to_text_callback(self, req):
res = SpeechToTextSrvResponse()
if req.language == '':
res.error = 'No language specified'
return res
# Getting the results in order to parse them
try:
transcripts = self.speech_to_text(\
req.filename,\
req.user,\
req.audio_type,\
req.language)
#print transcripts
except RappError as e:
res.error = e.value
return res
if len(transcripts['result']) == 0:
return res
# The alternative results
alternatives = transcripts['result'][0]['alternative']
res = SpeechToTextSrvResponse()
# If alternatives is 0 returns void response
if len(alternatives) > 0:
# The first alternative is Google's suggestion
words = alternatives[0]['transcript'].split(" ")
for w in words:
res.words = res.words + [w]
# Google provides the confidence for the first suggestion
if 'confidence' in alternatives[0].keys():
res.confidence.data = alternatives[0]['confidence']
else:
res.confidence.data = 0
for alt in alternatives[1:]:
sam = StringArrayMsg()
words = alt['transcript'].split(" ")
for w in words:
sam.s = sam.s + [w]
res.alternatives = res.alternatives + [sam]
else:
res.confidence.data = 0
return res
def speech_to_text_callback(self, req):
res = SpeechToTextSrvResponse()
if req.language == '':
res.error = 'No language specified'
return res
# Getting the results in order to parse them
try:
transcripts = self.speech_to_text(\
req.filename,\
req.user,\
req.audio_type,\
req.language)
#print transcripts
except RappError as e:
res.error = e.value
return res
if len(transcripts['result']) == 0:
return res
# The alternative results
alternatives = transcripts['result'][0]['alternative']
res = SpeechToTextSrvResponse()
# If alternatives is 0 returns void response
if len(alternatives) > 0:
# The first alternative is Google's suggestion
words = alternatives[0]['transcript'].split(" ")
for w in words:
res.words = res.words + [w]
# Google provides the confidence for the first suggestion
if 'confidence' in alternatives[0].keys():
res.confidence.data = alternatives[0]['confidence']
else:
res.confidence.data = 0
for alt in alternatives[1:]:
sam = StringArrayMsg()
words = alt['transcript'].split(" ")
for w in words:
sam.s = sam.s + [w]
res.alternatives = res.alternatives + [sam]
else:
res.confidence.data = 0
return res
def fetchData(self, req, tblName):
try:
res = fetchDataSrvResponse()
db_username, db_password = self.getLogin()
con = mdb.connect('localhost', db_username, db_password,
'RappStore')
cur = con.cursor()
returncols = self.constructCommaColumns(req.req_cols)
where = self.constructAndQuery(req.where_data)
query = "SELECT " + returncols + " FROM " + tblName + where
cur.execute(query)
result_set = cur.fetchall()
for i in range(len(result_set)):
line = StringArrayMsg()
for j in range(len(result_set[i])):
temp_s = String(result_set[i][j])
line.s.append((str(result_set[i][j])))
res.res_data.append(line)
con.close()
if (returncols == "*"):
res.res_cols = self.getTableColumnNames(tblName)
else:
res.res_cols = req.req_cols
res.success.data = True
res.trace.append("Success")
except mdb.Error, e:
res.trace.append(
("Database Error %d: %s" % (e.args[0], e.args[1])))
res.success.data = False
print "Error %d: %s" % (e.args[0], e.args[1])
def whatRappsCanRun(self,req,tblName):
#generic db read function
try:
res = whatRappsCanRunSrvResponse()
db_username,db_password=self.getLogin()
con = mdb.connect('localhost', db_username, db_password, 'RappStore');
cur = con.cursor()
#returncols=self.constructCommaColumns(req.req_cols)
#print returncols
#where=self.constructAndQuery(req.where_data)
#print where
#query="SELECT "+returncols+" FROM "+tblName+where
query="SELECT rapp_id from tblRappsModelsVersion where model_id='"+req.model_id+"' and minimum_coreagent_version<='"+req.core_agent_version+"'";
#print "fetch called"
cur.execute(query)
result_set = cur.fetchall()
for i in range(len(result_set)):
line=StringArrayMsg()
for j in range(len(result_set[i])):
temp_s=String(result_set[i][j])
line.s.append((str(result_set[i][j])))#=line.s+[String(data=temp_s)]
res.res_data.append(line)
con.close()
res.success.data=True
res.trace.append("Success")
except mdb.Error, e:
res.trace.append(("Database Error %d: %s" % (e.args[0],e.args[1])))
res.success.data=False
print "Error %d: %s" % (e.args[0],e.args[1])
def setNoiseProfile(self, req):
res = AudioProcessingSetNoiseProfileSrvResponse()
#-------------------------Check with database-------------------------#
authentication_service = rospy.ServiceProxy(self.serv_db_topic, fetchDataSrv)
req_db = fetchDataSrv()
req_db.req_cols=["username"]
entry1=["username", req.user]
req_db.where_data=[StringArrayMsg(s=entry1)]
resp = authentication_service(req_db.req_cols, req_db.where_data)
if resp.success.data != True or len(resp.res_data) == 0:
res.success = "false"
res.error = "Non authenticated user"
return res
#-------------------------set noise profile-------------------------#
ret = self.set_noise_profile_module.setNoise_profile(\
req.user,\
req.noise_audio_file,\
req.audio_file_type)
if ret == 'true':
res.success = ret
res.error = ''
else:
res.success = 'false'
res.error = ret
return res
def getUserLanguage(self, username, res):
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_fetch_data_topic')
knowrob_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
fetchDataSrvReq = fetchDataSrvRequest()
fetchDataSrvReq.req_cols = ["language"]
fetchDataSrvReq.where_data = [StringArrayMsg(s=["username", username])]
fetchDataSrvResponse = knowrob_service(fetchDataSrvReq)
if (fetchDataSrvResponse.success.data != True):
res.trace.extend(fetchDataSrvResponse.trace)
res.error = fetchDataSrvResponse.trace[0]
res.success = False
return True, ""
return False, fetchDataSrvResponse.res_data[0].s[0]
def testNullInputError(self):
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_robot_fetch_data_topic')
if (not serv_topic):
rospy.logerror("mysql_wrapper_robot_read_data_topic")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = []
entry1 = []
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0],
"IndexError: list index out of range")
self.assertFalse(response.success.data)
def retrieveDataFromTestXml(self, finalTestFilePath, res, userLanguage):
tree = ET.parse(finalTestFilePath)
root = tree.getroot()
res.testType = root.find("testType").text.encode('UTF-8')
res.testSubType = root.find("testSubType").text.encode('UTF-8')
language = root.find('Languages')
for question in language.find(userLanguage):
res.questions.append(question.find("body").text.encode('UTF-8'))
res.correctAnswers.append(
question.find("correctAnswer").text.encode('UTF-8'))
line = StringArrayMsg()
for answers in question.findall('answer'):
line.s.append(answers.find("body").text.encode('UTF-8'))
res.answers.append(line)
def testNullInputError(self):
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_robot_fetch_data_topic')
if (not serv_topic):
rospy.logerror("mysql_wrapper_robot_read_data_topic")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = []
entry1 = []
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(
response.trace[0],
"Wrong Query Input Format, check for empty required columns list or wrong/incomplete Query data format"
)
self.assertFalse(response.success.data)
def retrieveDataFromTestXml(self, testFilePath, userLanguage, res):
rospack = rospkg.RosPack()
testFilePath = rospack.get_path(
'rapp_cognitive_exercise') + testFilePath
tree = ET.parse(testFilePath)
root = tree.getroot()
res.testType = root.find("testType").text.encode('UTF-8')
res.testSubType = root.find("testSubType").text.encode('UTF-8')
res.test = root.find("name").text.encode('UTF-8')
language = root.find('Languages')
for question in language.find(userLanguage):
res.questions.append(question.find("body").text.encode('UTF-8'))
res.correctAnswers.append(
question.find("correctAnswer").text.encode('UTF-8'))
line = StringArrayMsg()
for answers in question.findall('answer'):
line.s.append(answers.find("body").text.encode('UTF-8'))
res.answers.append(line)
def whatRappsCanRun(self,req,tblName):
try:
res = whatRappsCanRunSrvResponse()
db_username,db_password=self.getLogin()
con = mdb.connect('localhost', db_username, db_password, 'RappStore');
cur = con.cursor()
query="SELECT rapp_id from tblRappsModelsVersion where model_id='"+req.model_id+"' and minimum_coreagent_version<='"+req.core_agent_version+"'";
cur.execute(query)
result_set = cur.fetchall()
for i in range(len(result_set)):
line=StringArrayMsg()
for j in range(len(result_set[i])):
temp_s=String(result_set[i][j])
line.s.append((str(result_set[i][j])))
res.res_data.append(line)
con.close()
res.success.data=True
res.trace.append("Success")
except mdb.Error, e:
res.trace.append(("Database Error %d: %s" % (e.args[0],e.args[1])))
res.success.data=False
res.error="Error %d: %s" % (e.args[0],e.args[1])
def speechRecognitionBatch(self, req):
total_res = SpeechRecognitionSphinx4TotalSrvResponse()
#-------------------------Check with database-------------------------#
if self.use_db_authentication == True:
req_db = fetchDataSrv()
req_db.req_cols = ["username"]
entry1 = ["username", req.user]
req_db.where_data = [StringArrayMsg(s=entry1)]
resp = self.authentication_service(req_db.req_cols,
req_db.where_data)
if resp.success.data != True or len(resp.res_data) == 0:
total_res.error = "Non authenticated user"
return total_res
conf_req = SpeechRecognitionSphinx4ConfigureSrvRequest()
spee_req = SpeechRecognitionSphinx4SrvRequest()
conf_req.language = req.language
conf_req.words = req.words
conf_req.grammar = req.grammar
conf_req.sentences = req.sentences
conf_res = SpeechRecognitionSphinx4ConfigureSrvResponse()
conf_res = self.configureSpeechRecognition(conf_req)
total_res.error = conf_res.error
if conf_res.error != '':
total_res.error = total_res.error + '\n' + conf_res.error
return total_res
spee_req.path = req.path
spee_req.audio_source = req.audio_source
spee_req.user = req.user
spee_res = self.speechRecognition(spee_req)
total_res.words = spee_res.words
total_res.error = spee_res.error
return total_res
def chooserFunction(self, req):
currentTimestamp = int(time.time()) #15552000000 for last 3 months
try:
res = testSelectorSrvResponse()
#obtain user's ontology alias. It will be created if it does not exist in case of invalid username it will be caught
serv_topic = rospy.get_param(
'rapp_knowrob_wrapper_create_ontology_alias')
if (not serv_topic):
rospy.logerror(
"rapp_knowrob_wrapper_create_ontology_alias param not found"
)
res.trace.append(
"rapp_knowrob_wrapper_create_ontology_alias param not found"
)
res.error = "rapp_knowrob_wrapper_create_ontology_alias param not found"
res.success = False
return res
rospy.wait_for_service(serv_topic)
knowrob_service = rospy.ServiceProxy(serv_topic,
createOntologyAliasSrv)
createOntologyAliasReq = createOntologyAliasSrvRequest()
createOntologyAliasReq.username = req.username
createOntologyAliasResponse = knowrob_service(
createOntologyAliasReq)
if (createOntologyAliasResponse.success != True):
res.trace.extend(createOntologyAliasResponse.trace)
res.error = createOntologyAliasResponse.error
res.success = False
return res
#get user language
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"rapp_mysql_wrapper_user_fetch_data_topic param not found")
res.trace.append(
"rapp_mysql_wrapper_user_fetch_data_topic param not found")
res.error = "mysql_wrapper_rapp_read_data topic param not found"
res.success = False
return res
rospy.wait_for_service(serv_topic)
knowrob_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
fetchDataSrvReq = fetchDataSrvRequest()
fetchDataSrvReq.req_cols = ["language"]
fetchDataSrvReq.where_data = [
StringArrayMsg(s=["username", req.username])
]
#print fetchDataSrvReq.where_data
fetchDataSrvResponse = knowrob_service(fetchDataSrvReq)
if (fetchDataSrvResponse.success.data != True):
#print fetchDataSrvResponse.res_data[0].s[0];
res.trace.extend(fetchDataSrvResponse.trace)
res.error = fetchDataSrvResponse.trace[0]
res.success = False
return res
userLanguage = fetchDataSrvResponse.res_data[0].s[0]
#print userLanguage
#
#Check if test type exists (if a test type is provided)
serv_topic = rospy.get_param(
'rapp_knowrob_wrapper_subclasses_of_topic')
if (not serv_topic):
rospy.logerror(
"rapp_knowrob_wrapper_subclasses_of_topic topic param not found"
)
res.trace.append(
"rapp_knowrob_wrapper_subclasses_of_topic topic param not found"
)
res.error = "rapp_knowrob_wrapper_subclasses_of_topic topic param not found"
res.success = False
return res
rospy.wait_for_service(serv_topic)
knowrob_service = rospy.ServiceProxy(serv_topic,
ontologySubSuperClassesOfSrv)
testTypesReq = ontologySubSuperClassesOfSrvRequest()
testTypesReq.ontology_class = "CognitiveTests"
testTypesResponse = knowrob_service(testTypesReq)
if (testTypesResponse.success != True):
res.trace.extend(testTypesResponse.trace)
res.trace.append("cannot load test categories from ontology")
res.error = testTypesResponse.error + "cannot load test categories from ontology"
res.success = False
return res
testTypesList = []
for s in testTypesResponse.results:
#res.trace.append(s)
tmpList = s.split('#')
testTypesList.append(tmpList[1])
serv_topic = rospy.get_param(
'rapp_knowrob_wrapper_user_performance_cognitve_tests')
if (not serv_topic):
rospy.logerror(
"rapp_knowrob_wrapper_user_performance_cognitve_tests topic not foud"
)
res.trace.append(
"mysql_wrapper_rapp_read_data topic param not found")
res.error = "mysql_wrapper_rapp_read_data topic param not found"
res.success = False
return res
if (req.testType == ""):
res.trace.append(
"no test type provided, will use least recently used")
noRecordsList = []
d1 = OrderedDict()
for s in testTypesList:
userPerformanceReq = userPerformanceCognitveTestsSrvRequest(
)
userPerformanceReq.test_type = s
userPerformanceReq.ontology_alias = createOntologyAliasResponse.ontology_alias
knowrob_service = rospy.ServiceProxy(
serv_topic, userPerformanceCognitveTestsSrv)
userPerformanceResponse = knowrob_service(
userPerformanceReq)
if (userPerformanceResponse.success != True):
noRecordsList.append(s)
else:
tmpUserPerfOrganizedByTimestamp = self.organizeUserPerformance(
userPerformanceResponse)
t1 = tmpUserPerfOrganizedByTimestamp.items()[0][0]
d1[t1] = [s]
if (len(noRecordsList) > 0):
req.testType = random.choice(noRecordsList)
res.trace.append(
"made random choice from the test types which were never used by the user, choice was: "
+ req.testType)
else:
d1 = OrderedDict(sorted(d1.items(), key=lambda t: t[0]))
req.testType = d1.values()[0][0]
res.trace.append(
"all test types had performance records.. least recently used one was :"
+ req.testType)
else:
if (req.testType not in testTypesList):
res.trace.append("testType provided does not exist")
res.error = "testType provided does not exist"
res.success = False
return res
# check if performance records exist for the selected test in order to determine the difficulty setting
noUserPerformanceRecordsExist = False
chosenDif = "1"
userPerformanceReq = userPerformanceCognitveTestsSrvRequest()
userPerformanceReq.test_type = req.testType
userPerformanceReq.ontology_alias = createOntologyAliasResponse.ontology_alias
knowrob_service = rospy.ServiceProxy(
serv_topic, userPerformanceCognitveTestsSrv)
userPerformanceResponse = knowrob_service(userPerformanceReq)
if (userPerformanceResponse.success != True):
res.trace.extend(userPerformanceResponse.trace)
res.trace.append(
"KnowRob wrapper returned no performance records for this user.. will start with a a difficulty setting of 1"
)
noUserPerformanceRecordsExist = True
else:
userPerfOrganizedByTimestamp = self.organizeUserPerformance(
userPerformanceResponse)
for k, v in userPerfOrganizedByTimestamp.items():
if (currentTimestamp - k > 15552000000):
del userPerfOrganizedByTimestamp[k]
else:
break
userScore = self.calculateUserScore(
userPerfOrganizedByTimestamp)
res.trace.append("user score :" + str(userScore))
if (userScore == 0):
chosenDif = "1"
elif (userScore < 0.75 * 100):
chosenDif = "1"
elif (userScore < 0.75 * 2 * 100):
chosenDif = "2"
else: #(userScore>0.75*3*100)
chosenDif = "3"
res.trace.append("Chosen Diff :" + chosenDif)
#Get cognitive tests of the selected type.
serv_topic = rospy.get_param(
'rapp_knowrob_wrapper_cognitive_tests_of_type')
if (not serv_topic):
rospy.logerror(
"rapp_knowrob_wrapper_cognitive_tests_of_type not found")
res.trace.append(
"rapp_knowrob_wrapper_cognitive_tests_of_type not found")
res.error = "rapp_knowrob_wrapper_cognitive_tests_of_type not found"
res.success = False
return res
cognitiveTestsOfTypeSrvReq = cognitiveTestsOfTypeSrvRequest()
cognitiveTestsOfTypeSrvReq.test_type = req.testType
cognitiveTestsOfTypeSrvReq.test_language = userLanguage
knowrob_service = rospy.ServiceProxy(serv_topic,
cognitiveTestsOfTypeSrv)
cognitiveTestsOfTypeResponse = knowrob_service(
cognitiveTestsOfTypeSrvReq)
if (cognitiveTestsOfTypeResponse.success != True):
res.trace.extend(cognitiveTestsOfTypeResponse.trace)
res.error = cognitiveTestsOfTypeResponse.error
res.success = False
return res
#print "after tests........."
#Filter the tests according to the determined difficulty
success, testsOfTypeOrdered = self.filterTestsbyDifficulty(
cognitiveTestsOfTypeResponse, chosenDif, res)
#If no test exists
if (not success): #not len(testsOfTypeOrdered)>0):
res.trace.append(
"Error, no tests of type contained in the ontology... cannot proceed"
)
res.error = "Error, no tests of type contained in the ontology... cannot proceed"
res.success = False
return res
#Choose the least recently used test of the given test type and difficulty and obtain the path to the xml file
finalTestname = ""
finalTestFilePath = ""
if (noUserPerformanceRecordsExist):
#print "inside no records"
finalTestname = random.choice(testsOfTypeOrdered.keys())
finalTest = testsOfTypeOrdered[finalTestname]
finalTestFilePath = finalTest[0][0]
else:
testsOfTypeOrderedCopy = testsOfTypeOrdered.copy()
for k, v in userPerfOrganizedByTimestamp.items():
if (v[0][0] in testsOfTypeOrderedCopy):
del testsOfTypeOrderedCopy[v[0][0]]
if (len(testsOfTypeOrderedCopy) > 0):
finalTestname = random.choice(
testsOfTypeOrderedCopy.keys())
finalTest = testsOfTypeOrderedCopy[finalTestname]
finalTestFilePath = finalTest[0][0]
else:
finalTestname = userPerfOrganizedByTimestamp.values()[
len(userPerfOrganizedByTimestamp) - 1]
finalTestname = finalTestname[0][0]
finalTest = testsOfTypeOrdered[finalTestname]
finalTestFilePath = finalTest[0][0]
#Retrieve the name of the selected test
tmpList = finalTestname.split('#')
res.test = tmpList[1]
#Parse the test xml file and retrieve the desired information
rospack = rospkg.RosPack()
localPackagePath = rospack.get_path('rapp_cognitive_exercise')
finalTestFilePath = localPackagePath + finalTestFilePath
res.trace.append(finalTestFilePath)
self.retrieveDataFromTestXml(finalTestFilePath, res, userLanguage)
res.language = userLanguage
res.success = True
except IndexError:
res.trace.append(
"Null pointer exception.. some argument was empty")
res.error = "Null pointer exception.. some argument was empty"
res.success = False
#print "Wrong Query Input Format, check for empty required columns list or wrong/incomplete Query data format"
except IOError:
res.success = False
res.trace.append("IO Error, cant open file or read data")
res.error = "IO Error, cant open file or read data"
return res
def testTblRobotWriteReadDeleteCheck(self):
#Write
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_robot_write_data_topic')
if (not serv_topic):
rospy.logerror(
"rapp_mysql_wrapper_robot_write_data_topic NOT FOUND ERROR")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, writeDataSrv)
req = writeDataSrv()
req.req_cols = [
] #[String(data="model_str"),String(data="manufacturer"),String(data="version"),String(data="arch"),String(data="os"),String(data="picture")]
#req.req_cols=[String("id"),String("macddr"), String("model"),String("owner"), String("timestamp")]
req.req_cols = ["macddr", "model", "owner", "timestamp"]
entry1 = StringArrayMsg()
entry1 = ["'1800000'", "'1'", "'25'", "'2014-11-23 09:04:13'"]
entry2 = StringArrayMsg()
entry2 = ["'1900000'", "'1'", "'25'", "'2014-11-23 07:04:13'"]
req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)]
response = db_service(req.req_cols, req.req_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Read what was written
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_robot_fetch_data_topic')
if (not serv_topic):
rospy.logerror("mysql_wrapper_robot_read_data_topic")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["macddr"]
entry1 = ["macddr", "1800000"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertEqual(response.res_data[0].s[0], "1800000")
#self.assertEqual(response.res_data[1].s[0].data,"extreme3")
#Update written
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_robot_update_data_topic')
if (not serv_topic):
rospy.logerror("mysql_wrapper_robot_update_data_topic")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, updateDataSrv)
req = updateDataSrv()
req.set_cols = ["timestamp='2014-11-23 09:04:13'"]
entry1 = ["macddr", '1900000']
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.set_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Read again
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_robot_fetch_data_topic')
if (not serv_topic):
rospy.logerror("mysql_wrapper_robot_fetch_data_topic")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["macddr", "model"]
entry1 = ["timestamp", "2014-11-23 09:04:13"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertEqual(response.res_data[0].s[0], "1800000")
self.assertEqual(response.res_data[1].s[0], "1900000")
#Delete updated
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_robot_delete_data_topic')
if (not serv_topic):
rospy.logerror("mysql_wrapper_robot_delete_data_topic")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv)
req = deleteDataSrv()
entry1 = ["timestamp", "2014-11-23 09:04:13"]
entry2 = ["model", "1"]
req.where_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)]
response = db_service(req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Check if it was deleted
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_robot_fetch_data_topic')
if (not serv_topic):
rospy.logerror("mysql_wrapper_robot_write_delete_topic")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["macddr", "model"]
entry1 = ["timestamp", "2014-11-23 09:04:13"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertTrue((len(response.res_data) < 1))
def testTblUserWriteReadDeleteCheck(self):
#Write
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_write_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_write_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, writeDataSrv)
req = writeDataSrv()
req.req_cols = [
"username", "firstname", "lastname", "email", "email_id",
"ontology_alias", "pwd", "usrgroup", "created", "accessed",
"enabled", "activation"
]
#req.req_cols=["idsd","macddr", "model","owner", "timestamp"]
entry1 = StringArrayMsg()
entry1 = [
"'testingDB1'", "'testingDB1'", "'testingDB1'", "'test@test'",
"NULL", "NULL", "'86'", "'0'", "'2014-15-15 18:01:34'",
"'0000-00-00 00:00:00'", "'1'", "'555'"
]
entry2 = StringArrayMsg()
entry2 = [
"'testingDB2'", "'testingDB2'", "'testingDB1'", "'test@test'",
"NULL", "NULL", "'86'", "'0'", "'2014-15-15 18:01:34'",
"'0000-00-00 00:00:00'", "'1'", "'555'"
]
req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)]
response = db_service(req.req_cols, req.req_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Read what was written
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_fetch_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["firstname", "lastname"]
entry1 = ["lastname", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertEqual(response.res_data[0].s[0], "testingDB1")
self.assertEqual(response.res_data[1].s[0], "testingDB2")
#Update written
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_update_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_update_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, updateDataSrv)
req = updateDataSrv()
req.set_cols = ["firstname='testingDB1'"]
entry1 = ["firstname", "testingDB2"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.set_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Read again
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_read_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["firstname", "lastname"]
entry1 = ["firstname", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertEqual(response.res_data[0].s[0], "testingDB1")
self.assertEqual(response.res_data[1].s[0], "testingDB1")
#Delete updated
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_delete_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_delete_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv)
req = deleteDataSrv()
entry1 = ["firstname", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Check if it was deleted
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_read_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["firstname", "lastname"]
entry1 = ["firstname", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertTrue((len(response.res_data) < 1))
def testTblModelWriteReadDeleteCheck(self):
#Write
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_model_write_data_topic')
if (not serv_topic):
rospy.logerror(
"rapp_mysql_wrapper_model_write_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, writeDataSrv)
req = writeDataSrv()
req.req_cols = [
"model_str", "manufacturer", "version", "arch", "os", "picture"
]
entry1 = StringArrayMsg()
entry1 = [
"'testingDB1'", "'testingDB1'", "'10.1'", "'test'", "'test'",
"'test'"
]
entry2 = StringArrayMsg()
entry2 = [
"'testingDB2'", "'testingDB1'", "'10.1'", "'test'", "'test'",
"'test'"
]
req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)]
response = db_service(req.req_cols, req.req_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Read what was written
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_model_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"rapp_mysql_wrapper_model_fetch_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["model_str", "manufacturer"]
entry1 = ["manufacturer", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertEqual(response.res_data[0].s[0], "testingDB1")
self.assertEqual(response.res_data[1].s[0], "testingDB2")
#Update written
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_model_update_data_topic')
if (not serv_topic):
rospy.logerror(
"rapp_mysql_wrapper_model_update_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, updateDataSrv)
req = updateDataSrv()
req.set_cols = ["model_str='testingDB3'"]
entry1 = ["model_str", "testingDB2"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.set_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Read again
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_model_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"rapp_mysql_wrapper_model_read_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["model_str", "manufacturer"]
entry1 = ["manufacturer", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertEqual(response.res_data[0].s[1], "testingDB1")
self.assertEqual(response.res_data[1].s[1], "testingDB1")
#Delete updated
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_model_delete_data_topic')
if (not serv_topic):
rospy.logerror(
"rapp_mysql_wrapper_model_delete_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv)
req = deleteDataSrv()
entry1 = ["manufacturer", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Check if it was deleted
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_model_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"rapp_mysql_wrapper_model_read_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["model_str", "manufacturer"]
entry1 = ["model_str", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertTrue((len(response.res_data) < 1))
def speech_to_text(self, file_path, user, audio_file_type, language):
# Check the user
serv_db_topic = rospy.get_param("rapp_mysql_wrapper_user_fetch_data_topic")
authentication_service = rospy.ServiceProxy(serv_db_topic, fetchDataSrv)
req_db = fetchDataSrv()
req_db.req_cols=["username"]
entry1=["username", user]
req_db.where_data=[StringArrayMsg(s=entry1)]
resp = authentication_service(req_db.req_cols, req_db.where_data)
if resp.success.data != True or len(resp.res_data) == 0:
raise RappError("Non authenticated user")
# Check if file exists
if not os.path.isfile(file_path):
raise RappError("Error: file " + file_path + ' not found')
# Check if file is flac. If not convert it
new_audio = file_path
audio_trans_topic = rospy.get_param("rapp_audio_processing_transform_audio_topic")
audio_transform_srv = rospy.ServiceProxy( audio_trans_topic, AudioProcessingTransformAudioSrv )
cleanup = []
transform_req = AudioProcessingTransformAudioSrvRequest()
transform_req.source_type = audio_file_type
transform_req.source_name = new_audio
transform_req.target_type = 'wav'
new_audio += '.wav'
transform_req.target_name = new_audio
transform_req.target_channels = 1
transform_req.target_rate = 16000
trans_response = audio_transform_srv( transform_req )
if trans_response.error != 'success':
raise RappError( trans_response.error )
cleanup.append(new_audio)
# Denoise if necessary
prev_audio_file = new_audio
next_audio_file = prev_audio_file
if audio_file_type in ['nao_ogg', 'nao_wav_1_ch', 'nao_wav_4_ch']:
denoise_topic = rospy.get_param("rapp_audio_processing_denoise_topic")
energy_denoise_topic = \
rospy.get_param("rapp_audio_processing_energy_denoise_topic")
denoise_service = rospy.ServiceProxy(\
denoise_topic, AudioProcessingDenoiseSrv)
energy_denoise_service = rospy.ServiceProxy(\
energy_denoise_topic, AudioProcessingDenoiseSrv)
manipulation = {}
manipulation['sox_transform'] = False
manipulation['sox_denoising'] = False
manipulation['sox_channels_and_rate'] = False
if audio_file_type == "headset":
pass
elif audio_file_type == "nao_ogg":
manipulation['sox_transform'] = True
manipulation['sox_denoising'] = True
manipulation['sox_denoising_scale'] = 0.15
elif audio_file_type == "nao_wav_4_ch":
manipulation['sox_channels_and_rate'] = True
manipulation['sox_denoising'] = True
manipulation['sox_denoising_scale'] = 0.15
elif audio_file_type == "nao_wav_1_ch":
manipulation['sox_denoising'] = True
manipulation['sox_denoising_scale'] = 0.15
manipulation['detect_silence'] = True
manipulation['detect_silence_threshold'] = 0.25
# Check if sox_transform is needed
if manipulation['sox_transform'] == True:
next_audio_file += "_transformed.wav"
command = "sox " + prev_audio_file + " " + next_audio_file
com_res = os.system(command)
if com_res != 0:
raise RappError("Error: sox malfunctioned")
cleanup.append(next_audio_file)
prev_audio_file = next_audio_file
if manipulation['sox_channels_and_rate'] == True:
next_audio_file += "_mono16k.wav"
command = "sox " + prev_audio_file + " -r 16000 -c 1 " + next_audio_file
com_res = os.system(command)
if com_res != 0:
raise RappError("Error: sox malfunctioned")
cleanup.append(next_audio_file)
prev_audio_file = next_audio_file
if manipulation['sox_denoising'] == True:
next_audio_file = prev_audio_file + "_denoised.wav"
den_request = AudioProcessingDenoiseSrvRequest()
den_request.audio_file = prev_audio_file
den_request.denoised_audio_file = next_audio_file
den_request.audio_type = audio_file_type
den_request.user = user
den_request.scale = manipulation['sox_denoising_scale']
den_response = denoise_service(den_request)
if den_response.success != "true":
raise RappError("Error:" + den_response.success)
cleanup.append(next_audio_file)
prev_audio_file = next_audio_file
# must implement a fallback function to clear redundant files
# Transform to flac
transform_req = AudioProcessingTransformAudioSrvRequest()
transform_req.source_type = 'headset'
transform_req.source_name = new_audio
transform_req.target_type = 'flac'
newer_audio = new_audio + '.flac'
transform_req.target_name = newer_audio
transform_req.target_channels = 1
transform_req.target_rate = 16000
trans_response = audio_transform_srv( transform_req )
cleanup.append(newer_audio)
if trans_response.error != 'success':
raise RappError( trans_response.error )
# Open the file
with open(newer_audio, "r") as f:
speech = f.read()
url = "www.google.com"
# Fix language
if language == 'en':
language = "en-US"
elif language == 'gr':
language = 'el'
#NOTE - Thats a general usage key. They may disable it in the future.
key = "AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw"
path = "/speech-api/v2/recognize?lang=" + language + "&key=" + key
headers = { "Content-type": "audio/x-flac; rate=22050" };
params = {"xjerr": "1", "client": "chromium"}
conn = httplib.HTTPSConnection(url)
conn.request("POST", path, speech, headers)
response = conn.getresponse()
data = response.read()
initial_data = data
# Google returns one empty result for some reason here. Removing it..
index = data.find("}")
data = data[index + 1:]
if data == '\n':
# Returned nothing.. something went wrong
data = initial_data
jsdata = json.loads(data)
# Remove the flac if needed
for f in cleanup:
command = 'rm -f ' + f
if os.system(command):
raise RappError("Error: Removal of temporary file malfunctioned")
return jsdata
def testTblUserWriteReadDeleteCheck(self):
#Write
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_write_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_write_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, writeDataSrv)
req = writeDataSrv()
req.req_cols = [
"name", "email", "pwd", "activated", "language", "ontology_alias"
]
#req.req_cols=["idsd","macddr", "model","owner", "timestamp"]
entry1 = StringArrayMsg()
entry1 = [
"'rappMysqlTestTemp1'", "'*****@*****.**'",
"'rappMysqlTestTemp1TestPass'", "'Y'", "'el'", "NULL"
]
entry2 = StringArrayMsg()
entry2 = [
"'rappMysqlTestTemp2'", "'*****@*****.**'",
"'rappMysqlTestTemp2TestPass'", "'Y'", "'el'", "NULL"
]
req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)]
response = db_service(req.req_cols, req.req_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Read what was written
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_fetch_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["name", "email"]
entry1 = ["name", "rappMysqlTestTemp1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertEqual(response.res_data[0].s[0], "rappMysqlTestTemp1")
#self.assertEqual(response.res_data[1].s[0],"*****@*****.**")
#Update written
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_update_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_update_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, updateDataSrv)
req = updateDataSrv()
req.set_cols = ["name='rappMysqlTestTemp1'"]
entry1 = ["name", "rappMysqlTestTemp2"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.set_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Read again
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_read_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["name", "email"]
entry1 = ["name", "rappMysqlTestTemp1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertEqual(response.res_data[0].s[0], "rappMysqlTestTemp1")
self.assertEqual(response.res_data[1].s[0], "rappMysqlTestTemp1")
#Delete updated
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_delete_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_delete_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv)
req = deleteDataSrv()
entry1 = ["name", "rappMysqlTestTemp1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Check if it was deleted
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_user_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_user_read_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["name", "email"]
entry1 = ["name", "rappMysqlTestTemp1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertTrue((len(response.res_data) < 1))
def testTblRappWriteReadDeleteCheck(self):
#Write
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_rapp_write_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_rapp_write_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, writeDataSrv)
req = writeDataSrv()
req.req_cols = [
"rapp", "version", "arch", "lang", "owner", "directory", "enabled",
"timestamp"
]
entry1 = StringArrayMsg()
entry1 = [
"'testingDB1'", "'1.01'", "'15'", "'1'", "'25'", "'testingDB1'",
"'0'", "'555'"
]
entry2 = StringArrayMsg()
entry2 = [
"'testingDB2'", "'1.01'", "'15'", "'1'", "'25'", "'testingDB1'",
"'0'", "'555'"
]
req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)]
response = db_service(req.req_cols, req.req_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Read what was written
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_rapp_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_rapp_fetch_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["rapp", "directory"]
entry1 = ["directory", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertEqual(response.res_data[0].s[0], "testingDB1")
self.assertEqual(response.res_data[1].s[0], "testingDB2")
#Update written
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_rapp_update_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_rapp_update_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, updateDataSrv)
req = updateDataSrv()
req.set_cols = ["rapp='testingDB3'"]
entry1 = ["rapp", "testingDB2"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.set_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Read again
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_rapp_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_rapp_read_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["rapp", "directory"]
entry1 = ["directory", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertEqual(response.res_data[0].s[0], "testingDB1")
self.assertEqual(response.res_data[1].s[0], "testingDB3")
#Delete updated
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_rapp_delete_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_rapp_delete_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv)
req = deleteDataSrv()
entry1 = ["directory", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
#Check if it was deleted
serv_topic = rospy.get_param(
'rapp_mysql_wrapper_rapp_fetch_data_topic')
if (not serv_topic):
rospy.logerror(
"mysql_wrapper_rapp_read_data topic param not found")
rospy.wait_for_service(serv_topic)
db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv)
req = fetchDataSrv()
req.req_cols = ["rapp", "directory"]
entry1 = ["directory", "testingDB1"]
req.where_data = [StringArrayMsg(s=entry1)]
response = db_service(req.req_cols, req.where_data)
self.assertEqual(response.trace[0], "Success")
self.assertTrue(response.success.data)
self.assertTrue((len(response.res_data) < 1))