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})