Allow transformation_add_MANUAL with an empty signature

bootstrap/core_algorithm.alc

@@ -1822,14 +1822,9 @@ String function transformation_add(source_models : Element, target_models : Elem
 			merged_formalism = get_full_model(get_entry_id("merged/" + operation_name), get_entry_id("formalisms/SimpleClassDiagrams"))
 
 		if (operation_type == "manual"):
-			if (dict_len(source_models) + dict_len(target_models) == 0):
-				return "Manual activity needs at least one formalism in its input or output signature!"!
 			// Finished with all information, now create the model itself!
 			Element m
 			m = get_full_model(get_entry_id("formalisms/ManualOperation"), get_entry_id("formalisms/SimpleClassDiagrams"))
-			if (element_eq(m, read_root())):
-				log("Error when opening ManualOperation: no conformance relation found")
-				return "Error when opening ManualOperation: no conformance relation found"!
 			model_create(instantiate_model(m), operation_name, get_entry_id("formalisms/ManualOperation"), "ManualOperation")
 			model_id = get_entry_id(operation_name)
 

unit/test_all.py

@@ -3775,9 +3775,92 @@ class TestModelverse(unittest.TestCase):
         # Model mismatch (target)
         assert transformation_between({"key_A": "users/user/test/A"}, {"key_B": "users/user/test/A"}) == set([])
 
+    def test_op_transformation_MANUAL(self):
+        # Add models for transformation
+        model_add("users/user/test/A", "formalisms/SimpleClassDiagrams", """
+            SimpleAttribute String {}
+            Class A {
+                name = "A"
+                name : String
+            }
+            """)
+        model_add("users/user/test/B", "formalisms/SimpleClassDiagrams", """
+            SimpleAttribute String {}
+            Class B {
+                name = "B"
+                name : String
+            }
+            """)
+        model_add("users/user/test/a", "users/user/test/A", """
+            A abc {
+                name = "1"
+            }
+            A def {
+                name = "2"
+            }
+            """)
+        model_add("users/user/test/b", "users/user/test/B", """
+            B {
+                name = "3"
+            }
+            """)
+
+        print("Finish model add")
+
+        # Add a transformation with normal signature
+        transformation_add_MANUAL({"MODEL_A": "users/user/test/A"}, {"MODEL_B": "users/user/test/B"}, "users/user/test/c")
+        print("Added manual 1")
+
+        # Add a transformation with empty signature
+        transformation_add_MANUAL({}, {}, "users/user/test/d")
+        print("Added manual 2")
+
+        def operation(model):
+            # Check if model correctly loaded with names rewritten
+            lst = element_list_nice(model)
+            assert len(lst) == 2
+            assert {"__id": "MODEL_A/abc", "__type": "MODEL_A/A", "name": "1"} in lst
+            assert {"__id": "MODEL_A/def", "__type": "MODEL_A/A", "name": "2"} in lst
+
+            # Make some changes to MODEL_A and make a MODEL_B
+            delete_element(model, "MODEL_A/abc")
+
+            lst = element_list_nice(model)
+            assert len(lst) == 1
+            assert {"__id": "MODEL_A/def", "__type": "MODEL_A/A", "name": "2"} in lst
+           
+            instantiate(model, "MODEL_B/B", ID="test_value")
+            attr_assign(model, "test_value", "name", "5")
+
+            lst = element_list_nice(model)
+            assert len(lst) == 2
+            assert {"__id": "MODEL_A/def", "__type": "MODEL_A/A", "name": "2"} in lst
+            assert {"__id": "test_value", "__type": "MODEL_B/B", "name": "5"} in lst
+
+        transformation_execute_MANUAL("users/user/test/c", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/a_2"}, operation)
+
+        # Check that users/user/test/a was NOT modified, as it was not part of the output signature
+        lst = element_list_nice("users/user/test/a")
+        assert len(lst) == 2
+        assert {"__id": "abc", "__type": "A", "name": "1"} in lst
+        assert {"__id": "def", "__type": "A", "name": "2"} in lst
+
+        # And check that new model is created
+        lst = element_list_nice("users/user/test/a_2")
+        assert len(lst) == 1
+        assert {"__id": "test_value", "__type": "B", "name": "5"} in lst
+
+        # Do the transformation again, now overwriting an existing model (of the correct type)
+        transformation_execute_MANUAL("users/user/test/c", {"MODEL_A": "users/user/test/a"}, {"MODEL_B": "users/user/test/b"}, operation)
+
+        lst = element_list_nice("users/user/test/b")
+        assert len(lst) == 1
+        assert {"__id": "test_value", "__type": "B", "name": "5"} in lst
+
+        # Do transformation
+
     """
     def test_op_model_render(self):
-    def test_op_transformation_between(self):
     def test_op_transformation_add_MT(self):
     def test_op_transformation_add_AL(self):
     def test_op_transformation_add_MANUAL(self):

wrappers/classes/modelverse.xml

@@ -141,7 +141,7 @@
                             <parameter expr='None'/>
                         </raise>
                         <script>
-                            #print("Request: " + str(value))
+                            print("Request: " + str(value))
                         </script>
                     </transition>
 
@@ -152,14 +152,14 @@
                             <parameter expr='None'/>
                         </raise>
                         <script>
-                            #print("Request: " + str(value))
+                            print("Request: " + str(value))
                         </script>
                     </transition>
 
                     <transition event="HTTP_output" cond="not self.finish_output_thread" target=".">
                         <parameter name="data"/>
                         <script>
-                            #print("Got input (%s): %s" % (self.taskname, data))
+                            print("Got input (%s): %s" % (self.taskname, data))
                             if self.taskname == "task_manager":
                                 self.controller.taskname = self.taskname = json.loads(data)
                             else:
@@ -686,13 +686,16 @@
                                         <parameter expr="self.parameters[3]"/>
                                     </raise>
                                 </transition>
-
-                                <transition cond="self.expect_response('Success')" target="../../../../wait_for_action/megamodelling">
-                                    <raise event="result">
-                                        <parameter expr="None"/>
-                                    </raise>
-                                </transition>
                             </state>
+
+                            <transition cond="self.expect_response('Success')" target="../../../wait_for_action/megamodelling">
+                                <script>
+                                    print("SUCCESS")
+                                </script>
+                                <raise event="result">
+                                    <parameter expr="None"/>
+                                </raise>
+                            </transition>
                         </state>
 
                         <state id="transformation_execute" initial="send_operation">
@@ -1385,6 +1388,13 @@
                         </raise>
                     </transition>
 
+                    <transition cond="self.expect_response_partial('Manual activity needs at least one formalism in its input or output signature', pop=True)" target="../wait_for_action/history">
+                        <raise event="exception">
+                            <parameter expr="'ManualActivityRequiresIO'"/>
+                            <parameter expr="'Manual activities require at least one input or output metamodel to be specified in order to create a meaningful metamodel.'"/>
+                        </raise>
+                    </transition>
+
                     <transition cond="self.expect_response_partial('Incorrect format: ', pop=False)" target="../wait_for_action/history">
                         <raise event="exception">
                             <parameter expr="'IncorrectFormat'"/>

wrappers/modelverse.py

@@ -21,9 +21,15 @@ class ModelverseException(Exception):
 class SuperclassAttribute(ModelverseException):
     pass
 
+class CallbackOnEmptySignature(ModelverseException):
+    pass
+
 class NotAModel(ModelverseException):
     pass
 
+class ManualActivityRequiresIO(ModelverseException):
+    pass
+
 class UserNotInGroup(ModelverseException):
     pass
 
@@ -312,36 +318,51 @@ def transformation_between(sources, targets):
 
 def transformation_add_MT(source_metamodels, target_metamodels, operation_name, code, callback=None):
     INPUT("transformation_add_MT", [source_metamodels, target_metamodels, operation_name, code, True])
-    model = OUTPUT()
 
-    if callback is not None:
-        __invoke(callback, model)
-    controller.addInput(Event("data_input", "action_in", [None]))
+    if len(source_metamodels) + len(target_metamodels) == 0:
+        if callback is not None:
+            raise CallbackOnEmptySignature()
+        return OUTPUT()
+    else:
+        model = OUTPUT()
+
+        if callback is not None:
+            __invoke(callback, model)
+        controller.addInput(Event("data_input", "action_in", [None]))
 
-    return OUTPUT()
+        return OUTPUT()
 
 def transformation_add_AL(source_metamodels, target_metamodels, operation_name, code, callback=None):
     INPUT("transformation_add_AL", [source_metamodels, target_metamodels, operation_name, code, True])
-    model = OUTPUT()
 
-    if model is not None:
-        # In case the source and target metamodels are empty, the model will be None, indicating that we are finished already (no callbacks allowed)
+    if len(source_metamodels) + len(target_metamodels) == 0:
+        if callback is not None:
+            raise CallbackOnEmptySignature()
+        return OUTPUT()
+    else:
+        model = OUTPUT()
 
         if callback is not None:
             __invoke(callback, model)
         controller.addInput(Event("data_input", "action_in", [None]))
 
-    return OUTPUT()
+        return OUTPUT()
 
 def transformation_add_MANUAL(source_metamodels, target_metamodels, operation_name, callback=None):
     INPUT("transformation_add_MANUAL", [source_metamodels, target_metamodels, operation_name, True])
-    model = OUTPUT()
 
-    if callback is not None:
-        __invoke(callback, model)
-    controller.addInput(Event("data_input", "action_in", [None]))
+    if len(source_metamodels) + len(target_metamodels) == 0:
+        if callback is not None:
+            raise CallbackOnEmptySignature()
+        return OUTPUT()
+    else:
+        model = OUTPUT()
+
+        if callback is not None:
+            __invoke(callback, model)
+        controller.addInput(Event("data_input", "action_in", [None]))
 
-    return OUTPUT()
+        return OUTPUT()
 
 def __transformation_execute(operation_name, input_models_dict, output_models_dict, statechart, tracability_model, fetch_output):
     if statechart is not None:

wrappers/modelverse_SCCD.py

@@ -1017,11 +1017,6 @@ class Modelverse(RuntimeClassBase):
         _initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_1.setTrigger(None)
         _initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_1.setGuard(self._initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_1_guard)
         self.states["/initialized/behaviour/operations/store_on_scripted/transformation_add/upload_changes"].addTransition(_initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_1)
-        _initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_2 = Transition(self, self.states["/initialized/behaviour/operations/store_on_scripted/transformation_add/upload_changes"], [self.states["/initialized/behaviour/wait_for_action/megamodelling"]])
-        _initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_2.setAction(self._initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_2_exec)
-        _initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_2.setTrigger(None)
-        _initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_2.setGuard(self._initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_2_guard)
-        self.states["/initialized/behaviour/operations/store_on_scripted/transformation_add/upload_changes"].addTransition(_initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_2)
         
         # transition /initialized/behaviour/operations/store_on_scripted/transformation_execute/send_operation
         _initialized_behaviour_operations_store_on_scripted_transformation_execute_send_operation_0 = Transition(self, self.states["/initialized/behaviour/operations/store_on_scripted/transformation_execute/send_operation"], [self.states["/initialized/behaviour/operations/store_on_scripted/transformation_execute/waiting"]])
@@ -1888,6 +1883,18 @@ class Modelverse(RuntimeClassBase):
         _initialized_behaviour_operations_29.setTrigger(None)
         _initialized_behaviour_operations_29.setGuard(self._initialized_behaviour_operations_29_guard)
         self.states["/initialized/behaviour/operations"].addTransition(_initialized_behaviour_operations_29)
+        _initialized_behaviour_operations_30 = Transition(self, self.states["/initialized/behaviour/operations"], [self.states["/initialized/behaviour/wait_for_action/history"]])
+        _initialized_behaviour_operations_30.setAction(self._initialized_behaviour_operations_30_exec)
+        _initialized_behaviour_operations_30.setTrigger(None)
+        _initialized_behaviour_operations_30.setGuard(self._initialized_behaviour_operations_30_guard)
+        self.states["/initialized/behaviour/operations"].addTransition(_initialized_behaviour_operations_30)
+        
+        # transition /initialized/behaviour/operations/store_on_scripted/transformation_add
+        _initialized_behaviour_operations_store_on_scripted_transformation_add_0 = Transition(self, self.states["/initialized/behaviour/operations/store_on_scripted/transformation_add"], [self.states["/initialized/behaviour/wait_for_action/megamodelling"]])
+        _initialized_behaviour_operations_store_on_scripted_transformation_add_0.setAction(self._initialized_behaviour_operations_store_on_scripted_transformation_add_0_exec)
+        _initialized_behaviour_operations_store_on_scripted_transformation_add_0.setTrigger(None)
+        _initialized_behaviour_operations_store_on_scripted_transformation_add_0.setGuard(self._initialized_behaviour_operations_store_on_scripted_transformation_add_0_guard)
+        self.states["/initialized/behaviour/operations/store_on_scripted/transformation_add"].addTransition(_initialized_behaviour_operations_store_on_scripted_transformation_add_0)
         
         # transition /initialized/behaviour/wait_for_action
         _initialized_behaviour_wait_for_action_0 = Transition(self, self.states["/initialized/behaviour/wait_for_action"], [self.states["/initialized/behaviour/wait_for_action/history"]])
@@ -2272,181 +2279,194 @@ class Modelverse(RuntimeClassBase):
         return self.expect_response_partial('Compilation error: ', pop=False)
     
     def _initialized_behaviour_operations_1_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['IncorrectFormat', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ManualActivityRequiresIO', 'Manual activities require at least one input or output metamodel to be specified in order to create a meaningful metamodel.']))
     
     def _initialized_behaviour_operations_1_guard(self, parameters):
-        return self.expect_response_partial('Incorrect format: ', pop=False)
+        return self.expect_response_partial('Manual activity needs at least one formalism in its input or output signature', pop=True)
     
     def _initialized_behaviour_operations_2_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['NotAModel', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['IncorrectFormat', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_2_guard(self, parameters):
-        return self.expect_response_partial('Not a model: ', pop=False)
+        return self.expect_response_partial('Incorrect format: ', pop=False)
     
     def _initialized_behaviour_operations_3_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownAttribute', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['NotAModel', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_3_guard(self, parameters):
-        return self.expect_response_partial('Attribute not found: ', pop=False)
+        return self.expect_response_partial('Not a model: ', pop=False)
     
     def _initialized_behaviour_operations_4_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['SuperclassAttribute', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownAttribute', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_4_guard(self, parameters):
-        return self.expect_response_partial('Attribute not defined here: ', pop=False)
+        return self.expect_response_partial('Attribute not found: ', pop=False)
     
     def _initialized_behaviour_operations_5_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownLocation', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['SuperclassAttribute', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_5_guard(self, parameters):
-        return self.expect_response_partial('Unknown location: ', pop=False)
+        return self.expect_response_partial('Attribute not defined here: ', pop=False)
     
     def _initialized_behaviour_operations_6_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownGroup', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownLocation', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_6_guard(self, parameters):
-        return self.expect_response_partial('Unknown group: ', pop=False)
+        return self.expect_response_partial('Unknown location: ', pop=False)
     
     def _initialized_behaviour_operations_7_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownUser', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownGroup', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_7_guard(self, parameters):
-        return self.expect_response_partial('Unknown user: ', pop=False)
+        return self.expect_response_partial('Unknown group: ', pop=False)
     
     def _initialized_behaviour_operations_8_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['NotAnAssociation', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownUser', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_8_guard(self, parameters):
-        return self.expect_response_partial('Not an association: ', pop=False)
+        return self.expect_response_partial('Unknown user: ', pop=False)
     
     def _initialized_behaviour_operations_9_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UserExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['NotAnAssociation', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_9_guard(self, parameters):
-        return self.expect_response_partial('User exists: ', pop=False)
+        return self.expect_response_partial('Not an association: ', pop=False)
     
     def _initialized_behaviour_operations_10_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ModelExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UserExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_10_guard(self, parameters):
-        return self.expect_response_partial('Model exists: ', pop=False)
+        return self.expect_response_partial('User exists: ', pop=False)
     
     def _initialized_behaviour_operations_11_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['GroupExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ModelExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_11_guard(self, parameters):
-        return self.expect_response_partial('Group exists: ', pop=False)
+        return self.expect_response_partial('Model exists: ', pop=False)
     
     def _initialized_behaviour_operations_12_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['FolderExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['GroupExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_12_guard(self, parameters):
-        return self.expect_response_partial('Folder exists: ', pop=False)
+        return self.expect_response_partial('Group exists: ', pop=False)
     
     def _initialized_behaviour_operations_13_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['AttributeExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['FolderExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_13_guard(self, parameters):
-        return self.expect_response_partial('Attribute exists: ', pop=False)
+        return self.expect_response_partial('Folder exists: ', pop=False)
     
     def _initialized_behaviour_operations_14_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownM3', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['AttributeExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_14_guard(self, parameters):
-        return self.expect_response_partial('Type cannot be typed as formalisms/SimpleClassDiagrams: ', pop=False)
+        return self.expect_response_partial('Attribute exists: ', pop=False)
     
     def _initialized_behaviour_operations_15_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ElementExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownM3', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_15_guard(self, parameters):
-        return self.expect_response_partial('Element exists: ', pop=False)
+        return self.expect_response_partial('Type cannot be typed as formalisms/SimpleClassDiagrams: ', pop=False)
     
     def _initialized_behaviour_operations_16_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ReadPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ElementExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_16_guard(self, parameters):
-        return self.expect_response_partial('Read permission denied to: ', pop=False)
+        return self.expect_response_partial('Element exists: ', pop=False)
     
     def _initialized_behaviour_operations_17_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ReadPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_17_guard(self, parameters):
-        return self.expect_response_partial('Write permission denied to: ', pop=False)
+        return self.expect_response_partial('Read permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_18_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.current_model]))
+        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_18_guard(self, parameters):
-        return self.expect_response('Write permission denied', pop=True)
+        return self.expect_response_partial('Write permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_19_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['NoSimpleClassDiagramsModel', 'Model is not a Simple Class Diagrams model and has no notion of defined attributes']))
+        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.current_model]))
     
     def _initialized_behaviour_operations_19_guard(self, parameters):
-        return self.expect_response_partial('Not a SimpleClassDiagrams model!', pop=True)
+        return self.expect_response('Write permission denied', pop=True)
     
     def _initialized_behaviour_operations_20_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ExecutePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['NoSimpleClassDiagramsModel', 'Model is not a Simple Class Diagrams model and has no notion of defined attributes']))
     
     def _initialized_behaviour_operations_20_guard(self, parameters):
-        return self.expect_response_partial('Execute permission denied to: ', pop=False)
+        return self.expect_response_partial('Not a SimpleClassDiagrams model!', pop=True)
     
     def _initialized_behaviour_operations_21_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['GroupPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ExecutePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_21_guard(self, parameters):
-        return self.expect_response_partial('Group permission denied to: ', pop=False)
+        return self.expect_response_partial('Execute permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_22_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UserPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['GroupPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_22_guard(self, parameters):
-        return self.expect_response_partial('User permission denied to: ', pop=False)
+        return self.expect_response_partial('Group permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_23_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UserNotInGroup', '']))
+        self.raiseInternalEvent(Event("exception", None, ['UserPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_23_guard(self, parameters):
-        return self.expect_response_partial('User is not a member of the group!', pop=True)
+        return self.expect_response_partial('User permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_24_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['AdminPermissionDenied', 'Admin permissions are required for this operation!']))
+        self.raiseInternalEvent(Event("exception", None, ['UserNotInGroup', '']))
     
     def _initialized_behaviour_operations_24_guard(self, parameters):
-        return self.expect_response_partial('Admin permission denied', pop=True)
+        return self.expect_response_partial('User is not a member of the group!', pop=True)
     
     def _initialized_behaviour_operations_25_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['InterfaceMismatch', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['AdminPermissionDenied', 'Admin permissions are required for this operation!']))
     
     def _initialized_behaviour_operations_25_guard(self, parameters):
-        return self.expect_response_partial('Incorrect format: ', pop=False)
+        return self.expect_response_partial('Admin permission denied', pop=True)
     
     def _initialized_behaviour_operations_26_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownElement', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['InterfaceMismatch', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_26_guard(self, parameters):
-        return self.expect_response_partial('Element not found: ', pop=False)
+        return self.expect_response_partial('Incorrect format: ', pop=False)
     
     def _initialized_behaviour_operations_27_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownModel', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownElement', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_27_guard(self, parameters):
-        return self.expect_response_partial('Model not found: ', pop=False)
+        return self.expect_response_partial('Element not found: ', pop=False)
     
     def _initialized_behaviour_operations_28_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownMetamodellingHierarchy', 'Metamodelling hierarchy could not be resolved or automatically inferred: there is no typing relation between your specified model and metamodel (%s)' % self.responses.pop(0)]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownModel', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_28_guard(self, parameters):
-        return self.expect_response_partial('Conformance hierarchy unknown for: ', pop=False)
+        return self.expect_response_partial('Model not found: ', pop=False)
     
     def _initialized_behaviour_operations_29_exec(self, parameters):
+        self.raiseInternalEvent(Event("exception", None, ['UnknownMetamodellingHierarchy', 'Metamodelling hierarchy could not be resolved or automatically inferred: there is no typing relation between your specified model and metamodel (%s)' % self.responses.pop(0)]))
+    
+    def _initialized_behaviour_operations_29_guard(self, parameters):
+        return self.expect_response_partial('Conformance hierarchy unknown for: ', pop=False)
+    
+    def _initialized_behaviour_operations_30_exec(self, parameters):
         print("Unknown Error: " + self.responses[0])
         pass
         self.raiseInternalEvent(Event("exception", None, ['UnknownError', 'Error: %s' % self.responses.pop(0)]))
     
-    def _initialized_behaviour_operations_29_guard(self, parameters):
+    def _initialized_behaviour_operations_30_guard(self, parameters):
         return self.expect_response_partial('', pop=False)
     
+    def _initialized_behaviour_operations_store_on_scripted_transformation_add_0_exec(self, parameters):
+        print("SUCCESS")
+        self.raiseInternalEvent(Event("result", None, [None]))
+    
+    def _initialized_behaviour_operations_store_on_scripted_transformation_add_0_guard(self, parameters):
+        return self.expect_response('Success')
+    
     def _initialized_behaviour_wait_for_action_0_exec(self, parameters):
         print("Got unknown operation: " + str(self.actions.pop(0)))
         self.raiseInternalEvent(Event("exception", None, ['UnknownOperation', 'Operation is unknown']))
@@ -2628,7 +2648,7 @@ class Modelverse(RuntimeClassBase):
     def _initialized_http_mapper_init_0_exec(self, parameters):
         value = parameters[0]
         self.big_step.outputEventOM(Event("narrow_cast", None, [self, self.http_clients[0], Event("HTTP_input", None, [urlencode({"op": "set_input", "data": json.dumps(value), "taskname": self.taskname}), None])]))
-        #print("Request: " + str(value))
+        print("Request: " + str(value))
     
     def _initialized_http_mapper_init_0_guard(self, parameters):
         value = parameters[0]
@@ -2637,7 +2657,7 @@ class Modelverse(RuntimeClassBase):
     def _initialized_http_mapper_init_1_exec(self, parameters):
         value = parameters[0]
         self.big_step.outputEventOM(Event("narrow_cast", None, [self, self.http_clients[0], Event("HTTP_input", None, [urlencode({"op": "set_input", "value": json.dumps(value), "taskname": self.taskname}), None])]))
-        #print("Request: " + str(value))
+        print("Request: " + str(value))
     
     def _initialized_http_mapper_init_1_guard(self, parameters):
         value = parameters[0]
@@ -2645,7 +2665,7 @@ class Modelverse(RuntimeClassBase):
     
     def _initialized_http_mapper_init_2_exec(self, parameters):
         data = parameters[0]
-        #print("Got input (%s): %s" % (self.taskname, data))
+        print("Got input (%s): %s" % (self.taskname, data))
         if self.taskname == "task_manager":
             self.controller.taskname = self.taskname = json.loads(data)
         else:
@@ -2932,12 +2952,6 @@ class Modelverse(RuntimeClassBase):
     def _initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_1_guard(self, parameters):
         return self.expect_response('Waiting for model constructors...')
     
-    def _initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_2_exec(self, parameters):
-        self.raiseInternalEvent(Event("result", None, [None]))
-    
-    def _initialized_behaviour_operations_store_on_scripted_transformation_add_upload_changes_2_guard(self, parameters):
-        return self.expect_response('Success')
-    
     def _initialized_behaviour_operations_store_on_scripted_transformation_execute_send_operation_0_exec(self, parameters):
         self.sub_sc_taskname = self.responses.pop(0).split(": ", 1)[1]
         self.raiseInternalEvent(Event("result", None, [self.sub_sc_taskname]))