def add_gateway_to_diagram(self,
process_id,
gateway_type,
gateway_name="",
gateway_direction="Unspecified",
node_id=None):
"""
Adds an exclusiveGateway element to BPMN diagram.
:param process_id: string object. ID of parent process,
:param gateway_type: string object. Type of gateway to be added.
:param gateway_name: string object. Name of exclusive gateway,
:param gateway_direction: string object. Accepted values - "Unspecified", "Converging", "Diverging", "Mixed".
Default value - "Unspecified",
:param node_id: string object. ID of node. Default value - None.
:return Returns a tuple, where first value is gateway ID, second a reference to created object.
"""
gateway_id, gateway = self.add_flow_node_to_diagram(
process_id, gateway_type, gateway_name, node_id)
if not (gateway_direction
in ("Unspecified", "Converging", "Diverging", "Mixed")):
raise bpmn_exception.BpmnPythonError(
"Invalid value passed as gatewayDirection parameter. Value passed: "
+ gateway_direction)
self.diagram_graph.node[gateway_id][
consts.Consts.gateway_direction] = gateway_direction
return gateway_id, gateway
def fill_graph_connections(process_dict, bpmn_diagram, sequence_flows):
"""
:param process_dict:
:param bpmn_diagram:
:param sequence_flows:
"""
nodes_ids = list(bpmn_diagram.diagram_graph.node.keys())
nodes_ids_to_process = copy.deepcopy(nodes_ids)
while bool(nodes_ids_to_process):
node_id = str(nodes_ids_to_process.pop(0))
if is_node_the_end_event(node_id, process_dict):
pass
elif is_there_sequence_continuation(node_id, nodes_ids):
possible_sequence_successors = get_possible_sequence_continuation_successor(node_id)
successor_node_id = get_possible_successor_present_in_node_ids_or_raise_excp(possible_sequence_successors,
nodes_ids)
add_connection(node_id, successor_node_id, process_dict, bpmn_diagram, sequence_flows)
elif is_there_split_continuation(node_id, nodes_ids):
split_gateway_id = add_split_gateway(node_id, nodes_ids, process_dict, bpmn_diagram)
add_connection(node_id, split_gateway_id, process_dict, bpmn_diagram, sequence_flows)
for successor_node_id in get_all_split_successors(node_id, nodes_ids):
add_connection(split_gateway_id, successor_node_id, process_dict, bpmn_diagram, sequence_flows)
pass
elif is_there_merge_continuation(node_id, nodes_ids):
possible_merge_successors = get_possible_merge_continuation_successors(node_id)
merge_successor_id = get_possible_successor_present_in_node_ids_or_raise_excp(possible_merge_successors,
nodes_ids)
merge_gateway_id, just_created = add_merge_gateway_if_not_exists(merge_successor_id, bpmn_diagram)
if just_created:
add_connection(merge_gateway_id, merge_successor_id, process_dict, bpmn_diagram, sequence_flows)
add_connection(node_id, merge_gateway_id, process_dict, bpmn_diagram, sequence_flows)
else:
raise bpmn_exception.BpmnPythonError("Something wrong in csv file syntax - look for " + node_id)
def get_possible_successor_present_in_node_ids_or_raise_excp(poissible_successors_node_id, nodes_ids):
"""
:param poissible_successors_node_id:
:param nodes_ids:
:return:
"""
possible_successor_set = get_possible_successors_set_present_in_node_ids(poissible_successors_node_id, nodes_ids)
if len(possible_successor_set) != 1:
raise bpmn_exception.BpmnPythonError("Some error in program - there should be exactly one found successor.")
else:
return possible_successor_set.pop()
def get_merge_node_type(merge_successor_id, bpmn_diagram):
"""
:param merge_successor_id:
:param bpmn_diagram:
:return:
"""
result = re.match(regex_pa_trailing_number, merge_successor_id)
if result:
trailing_number = result.group(2)
prev_prev_number = int(trailing_number) - 2
if prev_prev_number < 0:
raise bpmn_exception.BpmnPythonError("Something wrong in csv file syntax - look for " + merge_successor_id)
prefix = result.group(1)
split_node_id = prefix + str(prev_prev_number) + "_split"
if bool(bpmn_diagram.diagram_graph.has_node(split_node_id)):
node_type = bpmn_diagram.diagram_graph.node[split_node_id][consts.Consts.type]
if bool(node_type):
return node_type
return consts.Consts.inclusive_gateway
def get_all_split_successors(node_id, nodes_ids):
"""
:param node_id:
:param nodes_ids:
:return:
"""
result = re.match(regex_pa_trailing_number, node_id)
if not result:
raise bpmn_exception.BpmnPythonError("Something wrong in program - look for " + node_id)
trailing_number = result.group(2)
prefix = result.group(1)
new_trailing_number = str(int(trailing_number) + 1)
next_node_id = prefix + new_trailing_number
pattern = regex_prefix_split_succ + next_node_id + regex_suffix_split_succ
split_successors = []
for elem in nodes_ids:
if re.match(pattern, elem):
split_successors.append(elem)
return split_successors
def export_process_to_odt(bpmn_diagram, directory, filename):
"""
Root method of ODT export functionality.
:param bpmn_diagram: an instance of BpmnDiagramGraph class,
:param directory: a string object, which is a path of output directory,
:param filename: a string object, which is a name of output file.
"""
nodes = copy.deepcopy(bpmn_diagram.get_nodes())
start_nodes = []
export_elements = []
for node in nodes:
incoming_list = node[1].get(consts.Consts.incoming_flow)
if len(incoming_list) == 0:
start_nodes.append(node)
if len(start_nodes) != 1:
raise bpmn_exception.BpmnPythonError(
"Exporting to ODT format accepts only one start event")
nodes_classification = utils.BpmnImportUtils.generate_nodes_clasification(
bpmn_diagram)
start_node = start_nodes.pop()
bpmn_csv_export.BpmnDiagramGraphCsvExport\
.export_node(bpmn_diagram, export_elements, start_node, nodes_classification)
try:
os.makedirs(directory)
except OSError as exception:
if exception.errno != errno.EEXIST:
raise
item_list = BpmnDiagramGraphOdtExport.transform_into_list_items(
export_elements)
item_list = BpmnDiagramGraphOdtExport.reassign_goto(
item_list, export_elements)
item_list = map(lambda item: item["Prefix"] + item["Label"], item_list)
odt_file = directory + filename
BpmnDiagramGraphOdtExport.write_export_node_to_file(
odt_file, item_list)
def export_process_to_csv(bpmn_diagram, directory, filename):
"""
Root method of CSV export functionality.
:param bpmn_diagram: an instance of BpmnDiagramGraph class,
:param directory: a string object, which is a path of output directory,
:param filename: a string object, which is a name of output file.
"""
nodes = copy.deepcopy(bpmn_diagram.get_nodes())
start_nodes = []
export_elements = []
for node in nodes:
incoming_list = node[1].get(consts.Consts.incoming_flow)
if len(incoming_list) == 0:
start_nodes.append(node)
if len(start_nodes) != 1:
raise bpmn_exception.BpmnPythonError(
"Exporting to CSV format accepts only one start event")
nodes_classification = utils.BpmnImportUtils.generate_nodes_clasification(
bpmn_diagram)
start_node = start_nodes.pop()
BpmnDiagramGraphCsvExport.export_node(bpmn_diagram, export_elements,
start_node, nodes_classification)
try:
os.makedirs(directory)
except OSError as exception:
if exception.errno != errno.EEXIST:
raise
file_object = open(directory + filename, "w")
file_object.write(
"Order,Activity,Condition,Who,Subprocess,Terminated\n")
BpmnDiagramGraphCsvExport.write_export_node_to_file(
file_object, export_elements)
file_object.close()
