def add_process(input_dict: dict) -> dict:
"""
Function to add a single process
:param input_dict: process as a dictionary
:type input_dict: dict
:return: Status dict
"""
output = Process(
name=input_dict["process"]["name"],
responsible_person=input_dict["process"]["responsible_person"],
creation_timestamp=str(datetime.now()),
last_timestamp=str(datetime.now()),
description=input_dict["process"]["description"])
output.save()
for metric in input_dict["target_metrics"]:
output.hasMetric.connect(
metric_handler.Metric.nodes.get(name=metric), {
"average": input_dict["target_metrics"][metric]["average"],
"min": input_dict["target_metrics"][metric]["min"],
"max": input_dict["target_metrics"][metric]["max"]
})
output_dict = success_handler()
output_dict["process_uid"] = output.uid
return output_dict
def remove_metrics_unique_constraint() -> dict:
"""
Function to remove unique constraint on metric names
:return: success handler
"""
query = queries.remove_metrics_unique_constraint()
db.cypher_query(query)
return success_handler()
def get_process_list() -> dict:
"""
Function to retrieve a list of all processes
:return: List of processes in a dict
"""
output_dict = success_handler()
query = queries.get_process_list()
result, meta = db.cypher_query(query)
output_dict["processes"] = result[0][0]
return output_dict
def delete_process(input_dict: dict) -> dict:
"""
Function to delete a single process
:param input_dict: Identifier
:type input_dict: dict
:return: Status dict
"""
query = queries.delete_process(input_dict["uid"])
db.cypher_query(query)
return success_handler()
def get_component_list() -> dict:
"""
Function to retrieve a list of all existing components
:return: List of components in a dict
"""
output_dict = success_handler()
query = queries.get_component_list()
result, meta = db.cypher_query(query)
output_dict["components"] = result[0][0]
return output_dict
def delete_process_reference(input_dict: dict) -> dict:
"""
Function to delete a process reference (to a component not longer in the respective process)
:param input_dict: a dictionary including the process uid and a weight
:type input_dict: dict
:return: Status dict
"""
query = queries.delete_process_reference(input_dict['uid'],
input_dict['weight'])
db.cypher_query(query)
return success_handler()
def get_component(input_dict: dict) -> dict:
"""
Function to retrieve a single component
:param input_dict: Component uid
:type input_dict: dict
:return: Component dict
"""
output_dict = success_handler()
result, meta = db.cypher_query(queries.get_component(input_dict["uid"]))
output_dict["component"] = reformatter.reformat_component(result[0][0])
return output_dict
def update_process_reference(input_dict: dict) -> dict:
"""
Function to edit a process reference (to a component included in the respective process)
:param input_dict: process uid and an old and new weight
:type input_dict: dict
:return: Status dict
"""
query = queries.update_process_reference(input_dict["uid"],
input_dict["old_weight"],
input_dict["new_weight"])
db.cypher_query(query)
return success_handler()
def add_process_reference(input_dict: dict) -> dict:
"""
Function to add a process reference (to a component included in the respective process)
:param input_dict: a dictionary containing process uid, component id and weight
:type input_dict: dict
:return: Status dict
"""
query = queries.add_process_reference(input_dict['process_uid'],
input_dict['component_uid'],
input_dict["weight"])
db.cypher_query(query)
return success_handler()
def get_process(input_dict: dict) -> dict:
"""
Function to retrieve a single process
:param input_dict: process uid
:type input_dict: dict
:return: process dict
"""
output_dict = success_handler()
query = queries.get_process(input_dict["uid"])
result, meta = db.cypher_query(query)
output_dict["process"], output_dict[
"target_metrics"] = reformatter.reformat_process(result[0])
return output_dict
def get_metrics_data() -> dict:
"""
Function to get all metrics and their attributes
:return: Metrics dict
"""
query = queries.get_metrics_list()
result, meta = db.cypher_query(query)
output_dict = success_handler()
output_dict["metrics"] = {}
for metric in result[0][0]:
output_dict["metrics"][metric.pop('name')] = metric
return output_dict
def add_component(input_dict: dict) -> dict:
"""
Function to add a single component
:param input_dict: Component as a dictionary
:type input_dict: dict
:return: Status dict
"""
output = Component(name=input_dict["name"], category=input_dict["category"],
creation_timestamp=str(datetime.now()),
last_timestamp=str(datetime.now()), description=input_dict["description"])
output.save()
for metric in input_dict["metrics"]:
output.hasMetric.connect(metric_handler.Metric.nodes.get(name=metric), {"value": input_dict["metrics"][metric]})
return success_handler()
def update_component(input_dict: dict) -> dict:
"""
Function to update a single component
:param input_dict: Component as a dictionary
:type input_dict: dict
:return: Status dict
"""
uid = input_dict["uid"]
query = queries.update_component(uid, input_dict["name"], input_dict["category"], input_dict["description"],
str(datetime.now()))
db.cypher_query(query)
for metric in input_dict["metrics"]:
query = queries.update_component_metric(uid, metric, input_dict["metrics"][metric])
db.cypher_query(query)
return success_handler()
def create_from_frontend_json(path: str) -> dict:
"""
Function to create metrics out of the frontend definition file
:param path: Path to stored json
:type path: str
:return: Stats dict
"""
with open(path) as json_file:
data = json.load(json_file)
features = data["features"]
for key in features:
for metric in features[key]["metrics"]:
for fulfill in features[key]["metrics"][metric]["fulfilled_if"]:
Metric.create({'name': metric, "fulfilled_if": fulfill})
return success_handler()
def update_process(input_dict: dict) -> dict:
"""
Function to edit a single process
:param input_dict: process as a dictionary
:type input_dict: dict
:return: Status dict
"""
uid = input_dict["process"]["uid"]
query = queries.update_process(uid, input_dict["process"]["name"],
input_dict["process"]["responsible_person"],
input_dict["process"]["description"],
str(datetime.now()))
db.cypher_query(query)
for metric in input_dict["target_metrics"]:
metric_values = {}
if input_dict["target_metrics"][metric]["average"] is not None:
metric_values["average"] = input_dict["target_metrics"][metric][
"average"]
if input_dict["target_metrics"][metric]["min"] is not None:
metric_values["min"] = input_dict["target_metrics"][metric]["min"]
if input_dict["target_metrics"][metric]["max"] is not None:
metric_values["max"] = input_dict["target_metrics"][metric]["max"]
commas_needed = len(metric_values) - 1
metric_string = ""
loop_count = 0
for key in metric_values:
metric_string += key + ": " + str(metric_values[key])
if loop_count < commas_needed:
metric_string += ", "
loop_count += 1
query = queries.update_process_metric(uid, metric, metric_string)
db.cypher_query(query)
return success_handler()
