Updated printing of information on manual operations

bootstrap/core_algorithm.alc

@@ -712,7 +712,14 @@ Element function execute_operation(operation_id : String, input_models : Element
 		result = transform(merged_model, operation)
 	elif (exact_type == "ManualOperation"):
 		output("Please perform manual operation " + cast_value(full_name(operation_id)))
+		String model_name
+		model_name = ""
+		while (get_entry_id(model_name) != ""):
+			model_name = ".tmp/" + random_string(20)
+		output("Operating on: " + cast_string(model_name))
+		model_create(merged_model, model_name, merged_metamodel_id, "Model")
 		modify(merged_model, True)
+		model_delete(get_entry_id(model_name))
 		result = True
 	elif (exact_type == "ActionLanguage"):
 		Element func

models/upload_models.py

@@ -0,0 +1,54 @@
+import sys
+sys.path.append("wrappers")
+from modelverse import *
+
+init()
+login("admin", "admin")
+
+model_add("formalisms/ReachabilityGraph", "formalisms/SimpleClassDiagrams", open("models/reachability_graph.mvc", "r").read())
+model_add("formalisms/PetriNet", "formalisms/SimpleClassDiagrams", open("integration/code/pn_design.mvc", 'r').read())
+model_add("formalisms/Encapsulated_PetriNet", "formalisms/SimpleClassDiagrams", open("models/petrinet_ports.mvc", 'r').read())
+model_add("formalisms/PW_Plant", "formalisms/SimpleClassDiagrams", open("models/plant_PW.mvc", 'r').read())
+model_add("formalisms/PW_Environment", "formalisms/SimpleClassDiagrams", open("models/environment_PW.mvc", 'r').read())
+model_add("formalisms/PW_Control", "formalisms/SimpleClassDiagrams", open("models/control_PW.mvc", 'r').read())
+model_add("formalisms/Requirements", "formalisms/SimpleClassDiagrams", open("models/requirements.mvc", 'r').read())
+model_add("formalisms/Query", "formalisms/SimpleClassDiagrams", open("models/query.mvc", 'r').read())
+model_add("formalisms/Architecture", "formalisms/SimpleClassDiagrams", open("models/architecture.mvc", 'r').read())
+
+model_add("models/pm_powerwindow", "formalisms/ProcessModel", open("models/pm_req_analyse.mvc", 'r').read())
+
+transformation_add_MANUAL({"Requirements": "formalisms/Requirements"}, {"Requirements": "formalisms/Requirements"}, "models/revise_req")
+transformation_add_MANUAL({"Requirements": "formalisms/Requirements", "PW_Environment": "formalisms/PW_Environment"}, {"PW_Environment": "formalisms/PW_Environment"}, "models/revise_environment")
+transformation_add_MANUAL({"Requirements": "formalisms/Requirements", "PW_Plant": "formalisms/PW_Plant"}, {"PW_Plant": "formalisms/PW_Plant"}, "models/revise_plant")
+transformation_add_MANUAL({"Requirements": "formalisms/Requirements", "PW_Control": "formalisms/PW_Control"}, {"PW_Control": "formalisms/PW_Control"}, "models/revise_control")
+transformation_add_MANUAL({"Requirements": "formalisms/Requirements", "Query": "formalisms/Query"}, {"Query": "formalisms/Query"}, "models/revise_query")
+transformation_add_MANUAL({"Requirements": "formalisms/Requirements", "Architecture": "formalisms/Architecture"}, {"Architecture": "formalisms/Architecture"}, "models/revise_architecture")
+
+def tracability_CTRL2EPN(context):
+    instantiate(None, "Association", ("PW_Control/State", "Encapsulated_PetriNet/Place"), ID="CTRL2EPN_link", context=context)
+    instantiate(None, "Association", ("PW_Control/Transition", "Encapsulated_PetriNet/Transition"), ID="CTRL2EPN_tlink", context=context)
+
+def tracability_PLANT2EPN(context):
+    instantiate(None, "Association", ("PW_Plant/State", "Encapsulated_PetriNet/Place"), ID="PLANT2EPN_link", context=context)
+    instantiate(None, "Association", ("PW_Plant/Transition", "Encapsulated_PetriNet/Transition"), ID="PLANT2EPN_tlink", context=context)
+
+def tracability_ENV2EPN(context):
+    instantiate(None, "Association", ("PW_Environment/Event", "Encapsulated_PetriNet/Place"), ID="ENV2EPN_link", context=context)
+
+def tracability_EPN2PN(context):
+    instantiate(None, "Association", ("Encapsulated_PetriNet/Place", "PetriNet/Place"), ID="EPN2PN_transition_link", context=context)
+    instantiate(None, "Association", ("Encapsulated_PetriNet/Transition", "PetriNet/Transition"), ID="EPN2PN_place_link", context=context)
+
+transformation_add_MT({}, {"PW_Plant": "formalisms/PW_Plant", "PW_Environment": "formalisms/PW_Environment", "PW_Control": "formalisms/PW_Control", "Query": "formalisms/Query", "Architecture": "formalisms/Architecture", "Requirements": "formalisms/Requirements"}, "models/make_initial_models", open("models/initialize.mvc", 'r').read())
+transformation_add_MT({"PW_Plant": "formalisms/PW_Plant"}, {"Encapsulated_PetriNet": "formalisms/Encapsulated_PetriNet"}, "models/plant_to_EPN", open("models/plant_to_EPN.mvc", 'r').read(), tracability_PLANT2EPN)
+transformation_add_MT({"PW_Control": "formalisms/PW_Control"}, {"Encapsulated_PetriNet": "formalisms/Encapsulated_PetriNet"}, "models/control_to_EPN", open("models/control_to_EPN.mvc", 'r').read(), tracability_CTRL2EPN)
+transformation_add_MT({"PW_Environment": "formalisms/PW_Environment"}, {"Encapsulated_PetriNet": "formalisms/Encapsulated_PetriNet"}, "models/environment_to_EPN", open("models/environment_to_EPN.mvc", 'r').read(), tracability_ENV2EPN)
+transformation_add_MT({"Encapsulated_PetriNet": "formalisms/Encapsulated_PetriNet", "Architecture": "formalisms/Architecture"}, {"PetriNet": "formalisms/PetriNet"}, "models/combine_EPN", open("models/combine_EPN.mvc", 'r').read(), tracability_EPN2PN)
+transformation_add_MT({"ReachabilityGraph": "formalisms/ReachabilityGraph", "Query": "formalisms/Query"}, {"ReachabilityGraph": "formalisms/ReachabilityGraph"}, "models/match", open("models/matches.mvc", 'r').read())
+
+transformation_add_AL({"PetriNet": "formalisms/PetriNet"}, {"ReachabilityGraph": "formalisms/ReachabilityGraph"}, "models/reachability", open("models/reachability.alc", 'r').read())
+transformation_add_AL({"ReachabilityGraph": "formalisms/ReachabilityGraph"}, {}, "models/bfs", open("models/bfs.alc", 'r').read())
+transformation_add_AL({"EPN_Plant": "formalisms/Encapsulated_PetriNet", "EPN_Control": "formalisms/Encapsulated_PetriNet", "EPN_Environment": "formalisms/Encapsulated_PetriNet"}, {"Encapsulated_PetriNet": "formalisms/Encapsulated_PetriNet"}, "models/merge_EPN", open("models/merge_EPN.alc", 'r').read())
+
+transformation_add_AL({"Encapsulated_PetriNet": "formalisms/Encapsulated_PetriNet"}, {}, "epn_print", open("models/epn_print.alc").read())
+transformation_add_AL({"PetriNet": "formalisms/PetriNet"}, {}, "pn_print", open("models/pn_print.alc").read())

wrappers/classes/modelverse.xml

@@ -566,7 +566,10 @@
                         <transition cond="self.expect_response_partial('Success: ', pop=False)" target="../../wait_for_action/history">
                             <script>
                                 results = self.split_response(self.responses.pop(0))
-                                signature = {i[0]: i[1] for i in result[1:].strip().split(" : ", 1)}
+                                signature = {}
+                                for result in results:
+                                    key, value = result.strip().split(" : ", 1)
+                                    signature[key] = value
                             </script>
                             <raise event="result">
                                 <parameter expr="signature"/>
@@ -765,6 +768,15 @@
 
                             <state id="edit_model">
                                 <transition cond="self.expect_response_partial('Please perform manual operation ', pop=True)" target="."/>
+                                <transition cond="self.expect_response_partial('Operating on: ', pop=False)" target=".">
+                                    <script>
+                                        model = self.responses.pop(0).split(": ", 1)[1]
+                                        print("Operating on model " + str(model))
+                                    </script>
+                                    <raise event="result">
+                                        <parameter expr="model"/>
+                                    </raise>
+                                </transition>
                                 <transition cond="self.expect_response('Model loaded, ready for commands!')" target="../../../../going_scripted"/>
                                 <transition cond="self.expect_response('Success')" target="../../../../wait_for_action/megamodelling">
                                     <raise event="result">
@@ -839,24 +851,21 @@
                                     </state>
                                 </state>
 
-                                <state id="op" initial="init">
-                                    <state id="init">
-                                        <transition target="../processing">
-                                            <script>
-                                                self.context = str(uuid.uuid4())
-                                                self.actions[self.context] = []
-                                            </script>
-
-                                            <raise event="result">
-                                                <parameter expr="['OP', self.op_name, self.context]"/>
-                                            </raise>
-                                        </transition>
-                                    </state>
-
-                                    <state id="processing">
-                                        <transition cond="self.expect_response_partial('Please perform manual operation ', pop=True)" target="."/>
-                                        <transition cond="self.expect_response('Model loaded, ready for commands!')" target="../../../../../../going_scripted"/>
-                                    </state>
+                                <state id="op">
+                                    <transition cond="self.expect_response_partial('Please perform manual operation ', pop=True)" target="."/>
+                                    <transition cond="self.expect_response_partial('Operating on: ', pop=False)" target=".">
+                                        <script>
+                                            model = self.responses.pop(0).split(": ", 1)[1]
+                                            self.context = str(uuid.uuid4())
+                                            self.actions[self.context] = []
+                                            print("Operating on model " + str(model))
+                                        </script>
+
+                                        <raise event="result">
+                                            <parameter expr="['OP', self.op_name, self.context, model]"/>
+                                        </raise>
+                                    </transition>
+                                    <transition cond="self.expect_response('Model loaded, ready for commands!')" target="../../../../../going_scripted"/>
                                 </state>
 
                                 <transition cond="self.expect_response('Success', pop=True)" target="../executing"/>