def insert_file(col_id, file_path):
file_resource_uuid = helpers.generate_uuid()
file_name = col_id + ".png"
file_resource_uri = "share://Histograms/" + file_name
upload_resource_uuid = helpers.generate_uuid()
upload_resource_uri = "<http://mu.semte.ch/services/file-service/files/{uuid}>".format(
uuid=upload_resource_uuid)
file_size = os.stat(file_path).st_size
q = """
PREFIX ext: <http://mu.semte.ch/vocabularies/ext/>
PREFIX dct: <http://purl.org/dc/terms/>
PREFIX nfo: <http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#>
PREFIX dbpedia: <http://dbpedia.org/ontology/>
PREFIX nie: <http://www.semanticdesktop.org/ontologies/2007/01/19/nie#>
PREFIX mu: <http://mu.semte.ch/vocabularies/core/>
INSERT DATA {{
GRAPH <http://mu.semte.ch/application> {{
{uploadUri} a nfo:FileDataObject ;
mu:uuid "{uploadUuid}";
nfo:fileName "{fileName}";
nfo:fileSize "{size}"^^xsd:integer;
dct:created "{created}"^^xsd:dateTime;
dbpedia:fileExtension "png".
<{resourceUri}> a nfo:FileDataObject ;
mu:uuid "{resourceUuid}";
nfo:fileName "{fileName}";
nie:dataSource {uploadUri};
dct:created "{created}"^^xsd:dateTime;
nfo:fileSize "{size}"^^xsd:integer;
dbpedia:fileExtension "png".
}}
}}
""".format(uploadUri=upload_resource_uri,
uploadUuid=upload_resource_uuid,
resourceUuid=file_resource_uuid,
resourceUri=file_resource_uri,
fileName=file_name,
created=datetime.now(
timezone('Europe/Brussels')).isoformat(),
size=file_size)
print("Insert file")
helpers.query(q)
return upload_resource_uri
def build_insert_query(junction1, junction2, osm_segment_id):
mu_uri = "http://mu.semte.ch/vocabularies/ext/fietsroutes/"
voc_ns = rdflib.namespace.Namespace(mu_uri + "voc/")
res_ns = rdflib.namespace.Namespace(mu_uri + "resources/")
graph = rdflib.graph.Graph()
junction1_uri = rdflib.term.URIRef(junction1)
junction2_uri = rdflib.term.URIRef(junction2)
segment_uuid = helpers.generate_uuid()
segment_uri = rdflib.term.URIRef(mu_uri + "resources/" +
"segment/" + str(segment_uuid))
graph.add((segment_uri, # type MalletTopic
rdflib.namespace.RDF["type"],
voc_ns["segment"]))
graph.add((segment_uri, # type MalletTopic
rdflib.term.URIRef("http://mu.semte.ch/vocabularies/core/uuid"),
rdflib.term.Literal(str(segment_uuid))))
graph.add((segment_uri, # type MalletTopic
voc_ns["fromJunction"],
junction1_uri))
graph.add((segment_uri,
voc_ns["toJunction"],
junction2_uri))
graph.add((segment_uri,
voc_ns["hasOSMid"],
rdflib.term.Literal(osm_segment_id)))
return """
INSERT DATA {{
GRAPH <{0}> {{
{1}
}}
}}
""".format(os.getenv('MU_APPLICATION_GRAPH'), graph.serialize(format='nt').decode('utf-8'))
def build_topicprint_update_query(theme, topicscores):
""" Create a SPARQL-query for inserting the total (weighted) scores for
topics related to a certain curated theme.
topicscores takes a dictionary with {topic: score} -pairs
"""
mu_uri = "http://mu.semte.ch/vocabularies/ext/topic-tools/"
voc_ns = rdflib.namespace.Namespace(mu_uri + "voc/")
# res_ns = rdflib.namespace.Namespace(mu_uri + "resources/")
graph = rdflib.graph.Graph()
for topic, score in topicscores.items():
topic_uri = rdflib.term.URIRef(mu_uri + "resources/" + "TopicPrint/" +
helpers.generate_uuid())
graph.add((
rdflib.term.URIRef(theme), # Topic id
voc_ns["hasTopicPrint"],
topic_uri))
graph.add(
(topic_uri, rdflib.namespace.RDF["type"], voc_ns["TopicPrint"]))
graph.add((topic_uri, voc_ns["hasTopic"], rdflib.term.URIRef(topic)))
graph.add((topic_uri, voc_ns["hasScore"], rdflib.term.Literal(score)))
return """INSERT DATA {{
GRAPH <{0}> {{
{1}
}}
}}
""".format(os.getenv('MU_APPLICATION_GRAPH'),
graph.serialize(format='nt').decode('utf-8'))
def construct_insert_document(document_name,
file_uri,
graph=APPLICATION_GRAPH):
document = {"name": document_name, "created": datetime.now(TIMEZONE)}
document["uuid"] = generate_uuid()
document["uri"] = DOCUMENT_BASE_URI + document["uuid"]
query_template = Template("""
PREFIX dossier: <https://data.vlaanderen.be/ns/dossier#>
PREFIX mu: <http://mu.semte.ch/vocabularies/core/>
PREFIX dct: <http://purl.org/dc/terms/>
PREFIX nfo: <http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#>
PREFIX ext: <http://mu.semte.ch/vocabularies/ext/>
INSERT {
GRAPH $graph {
$document a dossier:Stuk ;
mu:uuid $uuid ;
dct:title $name ;
dct:created $created ;
ext:file $file .
}
}
WHERE {
GRAPH $graph {
$file a nfo:FileDataObject .
}
}
""")
return query_template.substitute(
graph=sparql_escape_uri(graph),
document=sparql_escape_uri(document["uri"]),
uuid=sparql_escape_string(document["uuid"]),
name=sparql_escape_string(document["name"]),
created=sparql_escape_datetime(document["created"]),
file=sparql_escape_uri(file_uri))
def build_learnedthemes_update_query(event, learnedthemes):
""" Create a SPARQL-query for attaching the machine-learned themes and their
weights to a certain event
learnedthemes takes a dictionary with {theme: score} -pairs
"""
mu_uri = "http://mu.semte.ch/vocabularies/ext/topic-tools/"
voc_ns = rdflib.namespace.Namespace(mu_uri + "voc/")
# res_ns = rdflib.namespace.Namespace(mu_uri + "resources/")
graph = rdflib.graph.Graph()
for theme, score in learnedthemes.items():
themescore_uri = rdflib.term.URIRef(mu_uri + "resources/" +
"LearnedThemeScore/" +
helpers.generate_uuid())
graph.add((rdflib.term.URIRef(event), voc_ns["hasLearnedThemeScore"],
themescore_uri))
graph.add((themescore_uri, rdflib.namespace.RDF["type"],
voc_ns["LearnedThemeScore"]))
graph.add((themescore_uri, voc_ns["hasLearnedTheme"],
rdflib.term.URIRef(theme)))
graph.add(
(themescore_uri, voc_ns["hasScore"], rdflib.term.Literal(score)))
return """INSERT DATA {{
GRAPH <{0}> {{
{1}
}}
}}
""".format(os.getenv('MU_APPLICATION_GRAPH'),
graph.serialize(format='nt').decode('utf-8'))
def build_insert_query(weights_by_subject):
mu_uri = "http://mu.semte.ch/vocabularies/ext/topic-tools/"
voc_ns = rdflib.namespace.Namespace(mu_uri + "voc/")
res_ns = rdflib.namespace.Namespace(mu_uri + "resources/")
retval = []
for subject, topics in weights_by_subject.items():
graph = rdflib.graph.Graph()
subject_uri = rdflib.term.URIRef(subject)
for topic, weight in topics.items():
topicscore_uri = res_ns[helpers.generate_uuid()]
mallet_topic_uri = rdflib.term.URIRef(mu_uri + "resources/" +
"malletTopic/" + str(topic))
graph.add((
subject_uri, # type MalletTopic
voc_ns["hasTopicScore"],
topicscore_uri))
graph.add((topicscore_uri, voc_ns["hasScore"],
rdflib.term.Literal(weight)))
graph.add((topicscore_uri, voc_ns["hasTopic"], mallet_topic_uri))
retval.append("""
INSERT DATA {{
GRAPH <{0}> {{
{1}
}}
}}
""".format(os.getenv('MU_APPLICATION_GRAPH'),
graph.serialize(format='nt').decode('utf-8')))
return retval
def construct_insert_signinghub_session_query(signinghub_session,
signinghub_session_uri):
signinghub_token_uri = SIGNINGHUB_TOKEN_BASE_URI + generate_uuid()
expiry_time = signinghub_session.last_successful_auth_time + signinghub_session.access_token_expiry_time
query_template = Template("""
PREFIX dct: <http://purl.org/dc/terms/>
PREFIX mu: <http://mu.semte.ch/vocabularies/core/>
PREFIX oauth-2.0: <http://kanselarij.vo.data.gift/vocabularies/oauth-2.0-session/>
INSERT DATA {
GRAPH $session_graph {
$signinghub_session a oauth-2.0:OauthSession ;
oauth-2.0:hasEndpointURI $signinghub_token_endpoint ;
oauth-2.0:hasTokenValue $token_uri .
$token_uri a oauth-2.0:BearerToken ;
dct:created $creation_time ;
oauth-2.0:hasTokenValue $token_value ;
oauth-2.0:hasExpirytime $expiry_time .
}
}""")
query_string = query_template.substitute(
session_graph=sparql_escape_uri(SESSION_GRAPH),
signinghub_session=sparql_escape_uri(signinghub_session_uri),
signinghub_token_endpoint=sparql_escape_uri(SIGNINGHUB_OAUTH_TOKEN_EP),
token_uri=sparql_escape_uri(signinghub_token_uri),
creation_time=sparql_escape_datetime(
signinghub_session.last_successful_auth_time.astimezone(TIMEZONE)),
expiry_time=sparql_escape_datetime(expiry_time.astimezone(TIMEZONE)),
token_value=sparql_escape_string(signinghub_session.access_token))
return query_string
def mine_tree(config):
id = helpers.generate_uuid()
process = {'id': id}
processes[id] = process
support = float(flask.request.args.get('support', '0.005'))
thread.start_new_thread(do_threaded_mining, (config, support, process))
return flask.Response(response = json.dumps(process) , status=202, mimetype="application/json")
def _build_signing_activity(mandatee_uri):
signing_activity_id = generate_uuid()
signing_activity_uri = uri.resource.signing_activity(signing_activity_id)
return {
"id": signing_activity_id,
"uri": signing_activity_uri,
"mandatee_uri": mandatee_uri
}
def download_sh_doc_to_kaleidos_doc(sh_package_id, sh_document_id, document_name):
virtual_file = download_sh_doc_to_mu_file(sh_package_id, sh_document_id)
doc = {
"uuid": generate_uuid(),
"name": document_name
}
doc["uri"] = DOC_BASE_URI + doc["uuid"]
ins_doc_query_string = construct_insert_document(document_name, virtual_file["uri"], SIGNED_DOCS_GRAPH)
sudo_update(ins_doc_query_string)
return doc
def __init__(self, name=None, uuid=None):
"""
Two ways to iniialize this object:
1. From an exiting column, then the uuid will not be none
and we will query the right column and fill in all fields
2. It's a new column, the name wil then not be none and the
uuid is none
"""
if (uuid is not None and name is None):
self.uuid = uuid
result = get_column_by_uuid(uuid)
self.name = extract_from_query(result, "name")
self.description = extract_from_query(result, "description")
self.note = extract_from_query(result, "note")
self.data_type = extract_from_query(result, "dataType")
self.quantity_kind = extract_from_query(result, "quantityKind")
self.unit = extract_from_query(result, "unit")
self.record_count = extract_from_query(result, "recordCount")
self.missing_count = extract_from_query(result, "missingCount")
self.null_count = extract_from_query(result, "nullCount")
self.min = extract_from_query(result, "min")
self.max = extract_from_query(result, "max")
self.mean = extract_from_query(result, "mean")
self.median = extract_from_query(result, "median")
self.common_values = extract_from_query(result, "commonValues")
self.job = extract_from_query(result, "job")
self.unit_specific_info = extract_from_query(
result, "unitSpecificInfo")
else:
self.uuid = helpers.generate_uuid()
self.name = name
self.path = None
self.description = None
self.note = None
self.disable_processing = False
self.data_type = None
self.quantity_kind = None
self.unit = None
self.record_count = None
self.missing_count = None
self.null_count = None
self.min = None
self.max = None
self.mean = None
self.median = None
self.common_values = None
self.file = None
self.job = None
self.unit_specific_info = None
def __init__(self, name):
self.uuid = helpers.generate_uuid()
self.name = name
self.path = None
self.description = None
self.note = None
self.disable_processing = False
self.data_type = None
self.quantity_kind = None
self.unit = None
self.record_count = None
self.missing_count = None
self.null_count = None
self.min = None
self.max = None
self.mean = None
self.median = None
self.common_values = None
def ensure_signinghub_machine_user_session():
sh_session_query = construct_get_signinghub_machine_user_session_query()
sh_session_results = sudo_query(sh_session_query)['results']['bindings']
if sh_session_results: # Restore SigningHub session
log("Found a valid SigningHub session.")
sh_session_result = sh_session_results[0]
g.sh_session = SigningHubSession(SIGNINGHUB_API_URL)
if CLIENT_CERT_AUTH_ENABLED:
g.sh_session.cert = (CERT_FILE_PATH, KEY_FILE_PATH) # For authenticating against VO-network
g.sh_session.access_token = sh_session_result["token"]["value"]
else: # Open new SigningHub session
log("No valid SigningHub session found. Opening a new one ...")
sh_session = open_new_signinghub_machine_user_session() # No scope, plain sudo user
sh_session_uri = SIGNINGHUB_SESSION_BASE_URI + generate_uuid()
sh_session_query = construct_insert_signinghub_session_query(sh_session, sh_session_uri)
sudo_update(sh_session_query)
sh_session_sudo_query = construct_mark_signinghub_session_as_machine_users_query(sh_session_uri)
sudo_update(sh_session_sudo_query)
g.sh_session = sh_session
def write_mallet_input(contents, dir):
"""
Place files for mallet input in input folder
contents: dictionary with "subject: text"-pairs
dir: folder for mallet input files
returns a "uuid: subject"-dictionary (as subject urls aren't valid filenames)
"""
retval = {}
for subject, text in contents.items():
fn = helpers.generate_uuid()
path = os.path.join(dir, fn)
with open(path, 'w') as f:
res = f.write(text)
if res > 0:
retval[fn] = subject
else:
helpers.log(
"Couldn't write {} to MALLET input file".format(fn))
return retval
def ensure_signinghub_session(mu_session_uri):
mu_session_query = construct_get_mu_session_query(mu_session_uri)
mu_session_result = sudo_query(mu_session_query)['results']['bindings']
if not mu_session_result:
raise NoQueryResultsException("Didn't find a mu-session associated with an account with email-address")
mu_session = mu_session_result[0]
sh_session_query = construct_get_signinghub_session_query(mu_session_uri)
sh_session_results = sudo_query(sh_session_query)['results']['bindings']
if sh_session_results: # Restore SigningHub session
log("Found a valid SigningHub session.")
sh_session_result = sh_session_results[0]
g.sh_session = SigningHubSession(SIGNINGHUB_API_URL)
if CLIENT_CERT_AUTH_ENABLED:
g.sh_session.cert = (CERT_FILE_PATH, KEY_FILE_PATH) # For authenticating against VO-network
g.sh_session.access_token = sh_session_result["token"]["value"]
else: # Open new SigningHub session
log("No valid SigningHub session found. Opening a new one ...")
sh_session = open_new_signinghub_machine_user_session(mu_session["email"]["value"])
sh_session_uri = SIGNINGHUB_SESSION_BASE_URI + generate_uuid()
sh_session_query = construct_insert_signinghub_session_query(sh_session, sh_session_uri)
sudo_update(sh_session_query)
sh_session_link_query = construct_attach_signinghub_session_to_mu_session_query(sh_session_uri, mu_session_uri)
sudo_update(sh_session_link_query)
g.sh_session = sh_session
def prepare_signing_flow(signinghub_session: SigningHubSession,
signflow_uri: str, piece_uris: typing.List[str]):
if len(piece_uris) == 0:
raise exceptions.InvalidArgumentException(
f"No piece to add specified.")
if len(piece_uris) > 1:
raise exceptions.InvalidArgumentException(
f"Signflow can only add 1 piece.")
piece_uri = piece_uris[0]
pieces = signing_flow.get_pieces(signflow_uri)
piece = query_result_helpers.ensure_1(pieces)
if piece["uri"] != piece_uri:
raise exceptions.InvalidStateException(
f"Piece {piece_uri} is not associated to signflow {signflow_uri}.")
get_file_query_string = _query_file_template.substitute(
graph=sparql_escape_uri(APPLICATION_GRAPH),
piece=sparql_escape_uri(piece_uri),
)
file_result = query(get_file_query_string)
file_records = query_result_helpers.to_recs(file_result)
file_record = query_result_helpers.ensure_1(file_records)
piece_uri = file_record["piece"]
file_name = file_record["piece_name"] + "." + file_record["file_extension"]
file_path = file_record["file_path"]
file_path = file_path.replace("share://", "/share/")
with open(file_path, "rb") as f:
file_content = f.read()
preparation_activity_id = generate_uuid()
preparation_activity_uri = uri.resource.preparation_activity(
preparation_activity_id)
signinghub_package = signinghub_session.add_package({
# package_name: "New Package", # Defaults to "Undefined"
"workflow_mode":
"ONLY_OTHERS" # OVRB staff who prepare the flows will never sign
})
signinghub_package_id = signinghub_package["package_id"]
signinghub_document = signinghub_session.upload_document(
signinghub_package_id,
file_content,
file_name,
SH_SOURCE,
convert_document=False)
signinghub_document_id = signinghub_document["documentid"]
sh_document_muid = generate_uuid()
signinghub_document_uri = uri.resource.signinghub_document(
signinghub_package_id, signinghub_document_id)
query_string = _update_template.substitute(
graph=sparql_escape_uri(APPLICATION_GRAPH),
signflow=sparql_escape_uri(signflow_uri),
preparation_activity=sparql_escape_uri(preparation_activity_uri),
preparation_activity_id=sparql_escape_string(preparation_activity_id),
piece=sparql_escape_uri(piece_uri),
sh_document=sparql_escape_uri(signinghub_document_uri),
sh_document_muid=sparql_escape_string(sh_document_muid),
sh_document_id=sparql_escape_string(str(signinghub_document_id)),
sh_package_id=sparql_escape_string(str(signinghub_package_id)),
)
update(query_string)
def form_valid(self, form):
employee = get_object_or_404(Employee ,identifier=self.request.session['employee_token'] ) if 'employee_token' in self.request.session else Employee.objects.create(identifier=generate_uuid())
menu = Menu.objects.get(uuid=self.kwargs.get("uuid"))
form.instance.employee = employee
form.instance.menu = menu
return super(CreateOrder, self).form_valid(form)
def get(self, request, uuid, *args, **kwargs):
form = self.form_class(initial=self.get_initial())
employee = get_object_or_404(Employee ,identifier=self.request.session['employee_token'] ) if 'employee_token' in self.request.session else Employee.objects.create(identifier=generate_uuid())
menu = Menu.objects.get(uuid=self.kwargs.get("uuid"))
if Order.objects.filter(menu=menu, employee=employee).exists():
return redirect(reverse_lazy('meals:selected_menu', kwargs={'uuid': uuid}))
##set session identifier
request.session['employee_token'] = str(employee.identifier)
#redirect to edit if iser alreadt orders
return render(request, self.template_name, {'form': form, 'menu': menu})
