def delete_apikey(self, key):
"""delete an apikey"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
query_laucher.execute_query(sqa.delete_apikey(key).query)
def get_value(self):
""" Build a request from a json whith the following contents :variates,constraintesRelations,constraintesFilters"""
self.log.debug("== Attribute Value ==")
data = {}
tse = TripleStoreExplorer(self.settings, self.request.session)
body = self.request.json_body
try:
results, query = tse.build_sparql_query_from_json(
body["variates"], body["constraintesRelations"], body["limit"],
True)
# Remove prefixes in the results table
data['values'] = results
if not body['export']:
return data
# Provide results file
ql = QueryLauncher(self.settings, self.request.session)
rb = ResultsBuilder(self.settings, self.request.session)
data['file'] = ql.format_results_csv(rb.build_csv_table(results))
except Exception as e:
#exc_type, exc_value, exc_traceback = sys.exc_info()
#traceback.print_exc(limit=8)
traceback.print_exc(file=sys.stdout)
data['values'] = ""
data['file'] = ""
data['error'] = traceback.format_exc(limit=8) + "\n\n\n" + str(e)
self.log.error(str(e))
return data
def test_triple_presence(self, graph, triple):
"""Test the presence of a triple in the triplestore
get if a triple is present in a specific graph of the triplestore
:param graph: the named graph
:type graph: string
:param triple: the triple to test
:type triple: string
:returns: Result of the test
:rtype: bool
"""
sqb = SparqlQueryGraph(self.settings, self.request.session)
query_laucher = QueryLauncher(self.settings, self.request.session)
query = sqb.prepare_query("""
SELECT count(*) AS ?count
WHERE {
GRAPH <""" + graph + """> {
""" + triple + """ .
}
}
""")
res = query_laucher.process_query(query)
print(bool(int(res[0]['count'])))
return bool(int(res[0]['count']))
def insert_metadatas(self, accessL):
"""
Insert the metadatas into the parent graph
"""
self.log.debug('--- insert_metadatas ---')
sqb = SparqlQueryBuilder(self.settings, self.session)
query_laucher = QueryLauncher(self.settings, self.session)
valAcces = 'public' if accessL else 'private'
ttl = '<' + self.graph + '> prov:generatedAtTime "' + self.timestamp + '"^^xsd:dateTime .\n'
ttl += '<' + self.graph + '> dc:creator "' + self.session[
'username'] + '" .\n'
ttl += '<' + self.graph + '> :accessLevel "' + valAcces + '" .\n'
ttl += '<' + self.graph + '> foaf:Group "' + self.session[
'group'] + '" .\n'
ttl += '<' + self.graph + '> prov:wasDerivedFrom "' + self.name + '" .\n'
ttl += '<' + self.graph + '> dc:hasVersion "' + get_distribution(
'Askomics').version + '" .\n'
ttl += '<' + self.graph + '> prov:describesService "' + os.uname(
)[1] + '" .\n'
if self.is_defined("askomics.endpoint"):
ttl += '<' + self.graph + '> prov:atLocation "' + self.get_param(
"askomics.endpoint") + '" .\n'
else:
raise ValueError("askomics.endpoint does not exit.")
sparql_header = sqb.header_sparql_config('')
query_laucher.insert_data(ttl, self.graph, sparql_header)
def build_sparql_query_from_json(self,
fromgraphs,
variates,
constraintes_relations,
limit,
send_request_to_tps=True):
"""
Build a sparql query from JSON constraints
"""
select = ' '.join(variates)
sqb = SparqlQueryBuilder(self.settings, self.session)
query_launcher = QueryLauncher(self.settings, self.session)
query = self.build_recursive_block('', constraintes_relations)
# if limit != None and limit > 0:
# query += ' LIMIT ' + str(limit)
if send_request_to_tps:
results = query_launcher.process_query(
sqb.custom_query(fromgraphs, select, query).query)
else:
results = []
return results, sqb.custom_query(fromgraphs, select, query).query
def delete_askograph(self):
"""Delete the askomics graph"""
sqb = SparqlQueryGraph(self.settings, self.request.session)
query_laucher = QueryLauncher(self.settings, self.request.session)
query_laucher.process_query(sqb.get_drop_named_graph('urn:sparql:test_askomics').query)
def empty(self):
#empty database
sqb = SparqlQueryBuilder(self.settings, self.request.session)
ql = QueryLauncher(self.settings, self.request.session)
namedGraphs = self.list_named_graphs()
for graph in namedGraphs:
ql.execute_query(sqb.get_delete_query_string(graph).query)
def delete_galaxy(self):
"""Delete galaxy triple for the user"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
query_laucher.execute_query(sqa.delete_galaxy(self.username).query)
def getUserAbstraction(self, service):
"""
Get the user abstraction (relation and entity as subject and object)
:return:
:rtype:
"""
data = {}
self.log.debug(
" =========== TripleStoreExplorer:getUserAbstraction ===========")
sqg = SparqlQueryGraph(self.settings, self.session)
ql = QueryLauncher(self.settings, self.session)
data['relations'] = ql.process_query(
sqg.get_abstraction_relation('owl:ObjectProperty').query)
data['subclassof'] = ql.process_query(
sqg.get_isa_relation_entities().query)
data['entities'] = ql.process_query(sqg.get_abstraction_entity().query)
data['attributes'] = ql.process_query(
sqg.get_abstraction_attribute_entity().query)
data['categories'] = ql.process_query(
sqg.get_abstraction_category_entity().query)
data['positionable'] = ql.process_query(
sqg.get_abstraction_positionable_entity().query)
data['graph'] = sqg.getGraphUser()
return data
def load_data_from_file(self, fp, urlbase):
"""
Load a locally created ttl file in the triplestore using http (with load_data(url)) or with the filename for Fuseki (with fuseki_load_data(fp.name)).
:param fp: a file handle for the file to load
:param urlbase:the base URL of current askomics instance. It is used to let triple stores access some askomics temporary ttl files using http.
:return: a dictionnary with information on the success or failure of the operation
"""
if not fp.closed:
fp.flush(
) # This is required as otherwise, data might not be really written to the file before being sent to triplestore
ql = QueryLauncher(self.settings, self.session)
if self.is_defined('askomics.load_url'):
urlbase = self.settings['askomics.load_url']
url = urlbase + "/ttl/" + self.session[
'username'] + '/' + os.path.basename(fp.name)
data = {}
data["status"] = "ok"
try:
if self.is_defined("askomics.file_upload_url"):
queryResults = ql.upload_data(fp.name, self.graph)
else:
queryResults = ql.load_data(url, self.graph)
except Exception as e:
self.log.error(self._format_exception(e))
raise e
finally:
os.remove(fp.name)
return data
def delete_users(self):
"""Delete the test users graph"""
sqb = SparqlQueryGraph(self.settings, self.request.session)
query_laucher = QueryLauncher(self.settings, self.request.session)
query_laucher.execute_query(
sqb.get_drop_named_graph('urn:sparql:test_askomics:users').query)
def update_email(self):
"""
change the mail of a user
"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
query_laucher.process_query(
sqa.update_mail(self.username, self.email).query)
def check_galaxy(self):
"""Check if user have galaxy triples"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
result = query_laucher.process_query(
sqa.check_galaxy(self.username).query)
return ParamManager.Bool(result[0]['status'])
def update_passwd(self):
"""
Change the password of a user, and his randomsalt
"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
query_laucher.process_query(
sqa.update_passwd(self.username, self.sha256_pw,
self.randomsalt).query)
def deleteMoState(self, urimo):
self.log.debug(' ***** Delete module ' + urimo + ' on TPS ***** ')
sqb = SparqlQueryBuilder(self.settings, self.session)
ql = QueryLauncher(self.settings, self.session)
ql.execute_query(
sqb.prepare_query("""
DELETE WHERE { GRAPH <""" + self.graph_modules + """> { <""" + urimo +
"""> ?p ?o } }
""").query)
def build_sparql_query_from_json(self, variates, constraintesRelations,
limit, sendRequestToTPS):
self.log.debug("variates")
self.log.debug(variates)
self.log.debug("constraintesRelations")
self.log.debug(constraintesRelations)
sqb = SparqlQueryBuilder(self.settings, self.session)
ql = QueryLauncher(self.settings, self.session)
res = ql.execute_query(sqb.get_list_named_graphs().query)
namedGraphs = []
#for indexResult in range(len(res['results']['bindings'])):
# namedGraphs.append(res['results']['bindings'][indexResult]['g']['value'])
req = ""
req += "SELECT DISTINCT " + ' '.join(variates) + "\n"
#TODO OFI: External Service do not work and, anyway, graphes have to be selectionned by the user in the UI
#
#for graph in namedGraphs:
# req += "FROM "+ "<"+graph+ ">"+"\n"
req += "WHERE \n"
req += self.buildRecursiveBlock('', constraintesRelations)
if limit != None and limit > 0:
req += " LIMIT " + str(limit)
sqb = SparqlQueryBuilder(self.settings, self.session)
prefixes = sqb.header_sparql_config(req)
query = prefixes + req
results = {}
if sendRequestToTPS:
ql = QueryLauncher(self.settings, self.session)
results = ql.process_query(query)
else:
# add comment inside query to inform user
query = "# endpoint = " + self.get_param(
"askomics.endpoint") + "\n" + query
return results, query
def set_username_by_email(self):
"""Get the username of a user by his email"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
result = query_laucher.process_query(
sqa.get_username_by_email(self.email).query)
# return result[0]['username']
self.username = result[0]['username']
def test_statistics(self):
#load files
self.it.empty()
self.it.load_test2()
ql = QueryLauncher(self.settings, self.request.session)
queryResults = ql.insert_data(':sujet :predicat :objet .', 'test',
'prefix :<test>')
server = queryResults.info()['server']
self.request.json_body = {'namedGraphs': ['test']}
self.askview.delete_graph()
data = self.askview.statistics()
assert data['ntriples'] == 279
assert data['nclasses'] == '6'
assert data['nentities'] == '19'
assert data['ngraphs'] == '5'
assert data['class'] == {
'Personne': {
'count': '7'
},
'Sexe': {
'count': '2'
},
'Instrument': {
'count': '2'
}
}
for key in data['metadata'].keys():
self.assertRegexpMatches(
key,
r'^urn:sparql:(instrument|enseigne|connait|joue|personne)\.tsv_[0-9]+\.[0-9]+$'
)
for key2 in data['metadata'][key]:
self.assertRegexpMatches(
key2, r'^(version|username|filename|loadDate|server)$')
if key2 == 'version':
assert data['metadata'][key][key2] == '2.0'
elif key2 == 'username':
assert data['metadata'][key][key2] == getpass.getuser()
elif key2 == 'filename':
self.assertRegexpMatches(
data['metadata'][key][key2],
r'^(instrument|enseigne|connait|joue|personne)\.tsv$')
elif key2 == 'loadDate':
self.assertRegexpMatches(data['metadata'][key][key2],
r'^[0-9]+\.[0-9]+$')
elif key2 == 'server':
assert data['metadata'][key][key2] == server
def get_galaxy_infos(self):
"""Get Galaxy url and apikey of a user"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
result = query_laucher.process_query(
sqa.get_galaxy_infos(self.username).query)
if result:
return result[0]
return []
def add_apikey(self, keyname):
"""Add an api key
:param keyname: the keyname
:type keyname: string
"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
query_laucher.execute_query(
sqa.add_apikey(self.username, keyname).query)
def getGraphUser(self, removeGraph=[]):
self.log.debug("=== setGraphUser ===")
settings = {}
#finding all private graph graph
qu = self.build_query_on_the_fly({
'select': '?g',
'query': 'GRAPH ?g {\n'+\
"?g dc:creator '" + self.session['username'] + "' . } ",
'post_action': 'GROUP BY ?g'
}, True)
ql = QueryLauncher(self.settings, self.session)
results = ql.process_query(qu.query)
settings['private'] = []
for elt in results:
if 'g' not in elt:
continue
if elt['g'] in removeGraph:
continue
settings['private'].append(elt['g'])
self.log.debug("setting['private']:\n" + str(settings['private']))
#finding all public graph
qu = self.build_query_on_the_fly(
{
'select': '?g',
'query': 'GRAPH ?g {\n' + "?g :accessLevel 'public'. } "
}, True)
ql = QueryLauncher(self.settings, self.session)
results = ql.process_query(qu.query)
settings['public'] = []
for elt in results:
if elt['g'] in removeGraph:
continue
settings['public'].append(elt['g'])
self.log.debug("setting['public']:\n" + str(settings['public']))
return settings
def create_user_graph(self):
"""
Create a subgraph for the user. All his data will be inserted in this subgraph
"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
ttl = '<' + self.settings['askomics.graph'] + ':' + self.username + \
'> rdfg:subGraphOf <' + self.settings['askomics.graph'] + '>'
header_ttl = sqa.header_sparql_config(ttl)
query_laucher.insert_data(ttl, self.settings["askomics.graph"], header_ttl)
def list_named_graphs(self):
sqb = SparqlQueryBuilder(self.settings, self.request.session)
ql = QueryLauncher(self.settings, self.request.session)
res = ql.execute_query(sqb.get_list_named_graphs().query)
namedGraphs = []
for indexResult in range(len(res['results']['bindings'])):
namedGraphs.append(
res['results']['bindings'][indexResult]['g']['value'])
return namedGraphs
def build_sparql_query_from_json2(self, variates, constraintes_relations,
limit, send_request_to_TPS):
"""
build a sparql query from json
"""
self.log.debug("variates")
self.log.debug(variates)
self.log.debug("constraintes_relations")
self.log.debug(constraintes_relations)
sqb = SparqlQueryBuilder(self.settings, self.session)
ql = QueryLauncher(self.settings, self.session)
req = ""
req += "SELECT DISTINCT " + ' '.join(variates) + "\n"
#TODO OFI: External Service do not work and, anyway, graphes have to be selectionned by the user in the UI
#
#for graph in namedGraphs:
# req += "FROM "+ "<"+graph+ ">"+"\n"
req += "WHERE \n"
req += self.build_recursive_block('', constraintes_relations)
if limit != None and limit > 0:
req += " LIMIT " + str(limit)
sqb = SparqlQueryBuilder(self.settings, self.session)
prefixes = sqb.header_sparql_config(req)
query = prefixes + req
results = {}
if send_request_to_TPS:
ql = QueryLauncher(self.settings, self.session)
results = ql.process_query(query)
else:
# add comment inside query to inform user
query = "# endpoint = " + self.get_param(
"askomics.endpoint") + "\n" + query
return results, query
def get_number_of_users(self):
"""
get the number of users in the TS
"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
result = query_laucher.process_query(sqa.get_number_of_users().query)
if len(result) <= 0:
return 0
return int(result[0]['count'])
def ckeck_key_belong_user(self, key):
"""Check if a key belong to a user"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
result = query_laucher.process_query(
sqa.ckeck_key_belong_user(self.username, key).query)
self.log.debug('---> result: ' + str(result))
if len(result) <= 0:
return False
return ParamManager.Bool(result[0]['count'])
def get_admins_emails(self):
"""
Get all admins emails
"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
result = query_laucher.process_query(sqa.get_admins_emails().query)
email_list = []
for dic in result:
email_list.append(re.sub(r'^mailto:', '', dic['email']))
return email_list
def moStateOnTPS(self):
'''
check if module files state is saved on the TPS.
if not all modules files are saved with the unchecked status !
'''
sqb = SparqlQueryBuilder(self.settings, self.session)
ql = QueryLauncher(self.settings, self.session)
results = ql.process_query(
sqb.build_query_on_the_fly(
{
'select':
'?uri ?module ?comment ?version ?graph ?state',
'from': [self.graph_modules],
'query':
'{\n' + '?uri rdfs:label ?module .\n' +
'?uri rdfs:comment ?comment .\n' +
'?uri :module_version ?version .\n' +
'?uri :module_state ?state .\n' +
'OPTIONAL { ?uri :module_graph ?graph . } \n' + '}\n'
}, True).query)
self.log.debug(' ***** module on TPS ***** ')
listMoOnTps = {}
for result in results:
result['checked'] = (result['state'] == "ok")
result['wait'] = (result['state'] == "wait")
listMoOnTps[result['module']] = 0
self.log.debug('module : ' + result['module'])
#=======================*************** A ENLEVER *********=======================================
#pour debugger
#if result['wait'] :
# result['wait'] = False
#==============================================================
self.log.debug(' ***** check Available Modules ***** ')
requestAgain = False
for mo in self.moduleFiles:
self.log.debug(" --> module " + mo)
if mo not in listMoOnTps:
self.log.debug(" --====== > new module < =======")
self.importMoSate(self.moduleFiles[mo], 'off')
requestAgain = True
if requestAgain:
return False
return results
def get_owner_of_apikey(self, key):
"""Get the owner of an API kei
[description]
:param key: The API key
:type key: string
"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
result = query_laucher.process_query(sqa.get_owner_apikey(key).query)
if result:
self.username = result[0]['username']
def check_email_in_database(self):
"""
Check if the email is present in the TS
"""
query_laucher = QueryLauncher(self.settings, self.session)
sqa = SparqlQueryAuth(self.settings, self.session)
result = query_laucher.process_query(
sqa.check_email_presence(self.email).query)
if len(result) <= 0:
return False
return ParamManager.Bool(result[0]['status'])
