twoją rolą jest bycie moim asystentem i pomoc w naprawie mojego kodu. Kontekst moim zadaniem jest przetworzenie modelu UML na kod w javie za pomocą transformacji M2T za pomocą ACCELEO muszę zamienić diagram aktywności na kod w javie. Przykład mój kod ma wyglądać tak że usecase1(){ if(decision node ) { usecase2 } else {usecase3}. Teraz przesyłam ci mój mod do generowania kodu [comment encoding = UTF-8 /]
[module generate('http://www.eclipse.org/uml2/5.0.0/UML')]

[template public generateJava(model : Model)]
[comment @main/]
[comment Generate separate files for each class /]
[for (cls : Class | model.allOwnedElements()->filter(Class))]
[generateClassFile(cls, model)/]
[/for]

[comment Generate main activity execution file /]
[generateMainActivityFile(model)/]

[template public generateWorkflowMethods()]

[template public generateClassFile(cls : Class, model : Model)]
[if (cls.name <> null)]
[file (cls.name + '.java', false, 'UTF-8')]
package generated;

import java.util.*;
import java.math.BigInteger;

/**
 * Generated class: [cls.name/]
 */
public class [cls.name/] {
    
    [comment Generate attributes /]
    [for (attr : Property | cls.ownedAttribute)]
    [if (attr.name <> null)]
    private [getJavaType(attr.type)/] [attr.name/];
    [/if]
    [/for]
    
    // Constructor
    public [cls.name/]() {
        [for (attr : Property | cls.ownedAttribute)]
        [if (attr.name <> null)]
        this.[attr.name/] = [getDefaultValue(attr.type)/];
        [/if]
        [/for]
    }
    
    [comment Generate getters and setters /]
    [for (attr : Property | cls.ownedAttribute)]
    [if (attr.name <> null)]
    public [getJavaType(attr.type)/] get[attr.name.toUpperFirst()/]() {
        return this.[attr.name/];
    }
    
    public void set[attr.name.toUpperFirst()/]([getJavaType(attr.type)/] [attr.name/]) {
        this.[attr.name/] = [attr.name/];
    }
    [/if]
    [/for]
    
    [comment Generate operations /]
    [for (op : Operation | cls.ownedOperation)]
    [if (op.name <> null)]
    public [getOperationReturnType(op)/] [op.name/]([getOperationParameters(op)/]) {
        System.out.println("Executing operation: [op.name/] in [cls.name/]");
        [if (getOperationReturnType(op) <> 'void')]
        return [getDefaultValue(op.type)/];
        [/if]
    }
    [/if]
    [/for]
    
    @Override
    public String toString() {
        return "[cls.name/]{}";
    }
}
[/file]
[/if]
[/template]

[template public generateMainActivityFile(model : Model)]
[file ('ActivityExecutor.java', false, 'UTF-8')]
package generated;

import java.util.*;
import java.math.BigInteger;

/**
 * Main Activity Executor
 * Model: [if (model.name <> null)][model.name/][else]ActivityModel[/if]
 */
public class ActivityExecutor {
    
    // Instance variables for all use cases and controllers
    [for (cls : Class | model.allOwnedElements()->filter(Class))]
    [if (cls.name <> null)]
    private [cls.name/] [cls.name.toLowerFirst()/];
    [/if]
    [/for]
    
    // Constructor - initialize all components
    public ActivityExecutor() {
        [for (cls : Class | model.allOwnedElements()->filter(Class))]
        [if (cls.name <> null)]
        this.[cls.name.toLowerFirst()/] = new [cls.name/]();
        [/if]
        [/for]
        
        // Setup associations/relationships
        setupRelationships();
    }
    
    private void setupRelationships() {
        // Setup relationships based on UML associations
        [for (assoc : Association | model.allOwnedElements()->filter(Association))]
        [if (assoc.memberEnd->size() >= 2)]
        [let end1 : Property = assoc.memberEnd->first()]
        [let end2 : Property = assoc.memberEnd->last()]
        [if (end1.type <> null and end2.type <> null and end1.name <> null)]
        // Association: [end1.type.name/] - [end2.type.name/]
        if ([end1.type.name.toLowerFirst()/] != null && [end2.type.name.toLowerFirst()/] != null) {
            // Setup bidirectional relationship if needed
        }
        [/if]
        [/let]
        [/let]
        [/if]
        [/for]
    }
    
    [comment Generate activities from model /]
    [for (activity : Activity | model.allOwnedElements()->filter(Activity))]
    [generateActivity(activity)/]
    [/for]
    
    [generateWorkflowMethods()/]
[generateUseCaseOrchestration(model)/]
    [generateUseCaseOrchestration(model)/]
    
    // Main execution method
    public static void main(String[] args) {
        ActivityExecutor executor = new ActivityExecutor();
        System.out.println("Starting Activity Diagram execution...");
        
        // Execute the main workflow
        executor.executeMainWorkflow();
        
        System.out.println("Activity Diagram execution completed.");
    }
}
[/file]
[/template]

[template public generateActivity(activity : Activity)]
[if (activity.name <> null)]
/**
 * Generated activity: [activity.name/]
 * Executes the complete workflow with decision-based branching
 */
public void execute[activity.name.toUpperFirst()/]() {
    System.out.println("=== Starting Activity: [activity.name/] ===");
    
    [comment Start from Initial Node and follow the flow /]
    [let initialNodes : OrderedSet(InitialNode) = activity.node->filter(InitialNode)]
    [if (initialNodes->size() > 0)]
    [for (initial : InitialNode | initialNodes)]
    // Starting workflow from initial node
    [generateFlowBasedExecution(initial, activity)/]
    [/for]
    [else]
    System.out.println("No initial node found - executing all actions");
    [for (action : OpaqueAction | activity.node->filter(OpaqueAction)]
    [generateUseCaseCall(action)/]
    [/for]
    [/if]
    [/let]
    
    System.out.println("=== Completed Activity: [activity.name/] ===");
}

[/if]
[/template]

[template public generateFlowBasedExecution(currentNode : ActivityNode, activity : Activity)]
[if (currentNode.oclIsTypeOf(InitialNode))]
// Initial Node - start execution
System.out.println("Starting workflow...");
[generateNextNodes(currentNode, activity)/]

[elseif (currentNode.oclIsTypeOf(OpaqueAction))]
// Execute Use Case
[generateUseCaseCall(currentNode)/]
[generateNextNodes(currentNode, activity)/]

[elseif (currentNode.oclIsTypeOf(DecisionNode))]
// Decision Node - conditional branching
[generateDecisionLogic(currentNode, activity)/]

[elseif (currentNode.oclIsTypeOf(ActivityFinalNode))]
// Final Node - end execution
System.out.println("Workflow completed successfully.");

[elseif (currentNode.oclIsTypeOf(ActivityParameterNode))]
// Parameter Node
[if (currentNode.name <> null)]
System.out.println("Processing parameter: [currentNode.name/]");
[/if]
[generateNextNodes(currentNode, activity)/]

[else]
// Other nodes
[if (currentNode.name <> null)]
System.out.println("Processing node: [currentNode.name/]");
[/if]
[generateNextNodes(currentNode, activity)/]
[/if]
[/template]

[template public generateNextNodes(currentNode : ActivityNode, activity : Activity)]
[for (edge : ControlFlow | currentNode.outgoing->filter(ControlFlow))]
[if (edge.target <> null)]
[generateFlowBasedExecution(edge.target, activity)/]
[/if]
[/for]
[/template]

[template public generateDecisionLogic(decisionNode : DecisionNode, activity : Activity)]
[if (decisionNode.name <> null)]
// Decision: [decisionNode.name/]
boolean decision[decisionNode.name.replaceAll(' ', '')/] = makeDecision("[decisionNode.name/]");
[else]
// Unnamed Decision
boolean decision = makeDecision("UnnamedDecision");
[/if]

[comment Generate if-else structure based on outgoing edges with guards /]
[let outgoingEdges : OrderedSet(ControlFlow) = decisionNode.outgoing->filter(ControlFlow)]
[if (outgoingEdges->size() >= 2)]
[let trueEdge : ControlFlow = outgoingEdges->select(e | e.guard <> null and (e.guard.oclAsType(LiteralBoolean).value = true or e.guard.name = 'Tak' or e.guard.name = 'true' or e.guard.name = 'True'))->first()]
[let falseEdge : ControlFlow = outgoingEdges->select(e | e.guard <> null and (e.guard.oclAsType(LiteralBoolean).value = false or e.guard.name = 'Nie' or e.guard.name = 'false' or e.guard.name = 'False'))->first()]

[if (decisionNode.name <> null)]
if (decision[decisionNode.name.replaceAll(' ', '')/]) {
[else]
if (decision) {
[/if]
    System.out.println("Decision: Taking TRUE branch");
    [if (trueEdge <> null and trueEdge.target <> null)]
    [generateFlowBasedExecution(trueEdge.target, activity)/]
    [else]
    // No true branch target found
    [if (outgoingEdges->first().target <> null)]
    [generateFlowBasedExecution(outgoingEdges->first().target, activity)/]
    [/if]
    [/if]
} else {
    System.out.println("Decision: Taking FALSE branch");
    [if (falseEdge <> null and falseEdge.target <> null)]
    [generateFlowBasedExecution(falseEdge.target, activity)/]
    [else]
    // No false branch target found
    [if (outgoingEdges->last().target <> null)]
    [generateFlowBasedExecution(outgoingEdges->last().target, activity)/]
    [/if]
    [/if]
}

[/let]
[/let]
[else]
// Decision node with single or no outgoing edges
[for (edge : ControlFlow | outgoingEdges)]
[if (edge.target <> null)]
[generateFlowBasedExecution(edge.target, activity)/]
[/if]
[/for]
[/if]
[/let]
[/template]

[template public generateUseCaseCall(action : OpaqueAction)]
[if (action.name <> null)]
[comment Check if this action corresponds to a use case /]
[let actionName : String = action.name]
[if (actionName.contains('UseCase') or actionName.contains('usecase') or actionName.contains('Usecase'))]
// Execute Use Case: [actionName/]
[comment Try to find matching use case class /]
[let useCaseName : String = actionName.replaceAll('UseCase', 'Usecase').replaceAll('usecase', 'Usecase')]
try {
    System.out.println(">> Executing Use Case: [useCaseName/]");
    [comment Generate call to appropriate use case method /]
    if ([useCaseName.toLowerFirst()/] != null) {
        [comment Look for operations in use case classes /]
        [for (cls : Class | action.activity.owner.oclAsType(Model).allOwnedElements()->filter(Class)->select(c | c.name = useCaseName))]
        [for (op : Operation | cls.ownedOperation)]
        [if (op.name <> null)]
        [if (getOperationReturnType(op) <> 'void')]
        [getOperationReturnType(op)/] result = [useCaseName.toLowerFirst()/].[op.name/]([getDefaultParameterValues(op)/]);
        System.out.println("   Result: " + result);
        [else]
        [useCaseName.toLowerFirst()/].[op.name/]([getDefaultParameterValues(op)/]);
        [/if]
        System.out.println("   ✓ [useCaseName/].[op.name/]() completed");
        [/if]
        [/for]
        [/for]
    } else {
        System.out.println("   ⚠ [useCaseName/] instance not found");
    }
} catch (Exception e) {
    System.err.println("   ✗ Error executing [useCaseName/]: " + e.getMessage());
}
[/let]
[else]
// Execute Action: [actionName/]
performAction("[actionName/]");
[/if]
[/let]
[else]
// Execute unnamed action
performAction("UnnamedAction");
[/if]
[/template]

[template public generateUseCaseOrchestration(model : Model)]
/**
 * Main workflow orchestration - executes use cases in logical order
 */
public void executeMainWorkflow() {
    System.out.println("=== MAIN WORKFLOW EXECUTION ===");
    
    try {
        // Step 1: Initialize controllers
        System.out.println("Step 1: Initializing controllers...");
        [for (cls : Class | model.allOwnedElements()->filter(Class)->select(c | c.name.contains('Controller')))]
        [if (cls.name <> null)]
        System.out.println("  - Initialized [cls.name/]");
        [/if]
        [/for]
        
        // Step 2: Execute use cases in dependency order
        System.out.println("\nStep 2: Executing use cases...");
        
        [comment Find use cases and execute them in logical order /]
        [let useCaseClasses : OrderedSet(Class) = model.allOwnedElements()->filter(Class)->select(c | c.name.startsWith('Usecase'))]
        [for (useCase : Class | useCaseClasses)]
        [if (useCase.name <> null)]
        executeUseCaseStep("[useCase.name/]");
        [/if]
        [/for]
        [/let]
        
        // Step 3: Execute activities if present
        [for (activity : Activity | model.allOwnedElements()->filter(Activity))]
        [if (activity.name <> null)]
        System.out.println("\nStep 3: Executing activity workflow...");
        execute[activity.name.toUpperFirst()/]();
        [/if]
        [/for]
        
        System.out.println("\n=== WORKFLOW COMPLETED SUCCESSFULLY ===");
        
    } catch (Exception e) {
        System.err.println("Error during workflow execution: " + e.getMessage());
        e.printStackTrace();
    }
}

/**
 * Execute individual use case with proper error handling
 */
private void executeUseCaseStep(String useCaseName) {
    System.out.println("  -> Executing " + useCaseName + "...");
    
    try {
        [comment Generate specific execution logic for each use case /]
        [for (cls : Class | model.allOwnedElements()->filter(Class)->select(c | c.name.startsWith('Usecase')))]
        [if (cls.name <> null)]
        if (useCaseName.equals("[cls.name/]")) {
            [for (op : Operation | cls.ownedOperation)]
            [if (op.name <> null)]
            [if (getOperationReturnType(op) <> 'void')]
            [getOperationReturnType(op)/] result = [cls.name.toLowerFirst()/].[op.name/]([getDefaultParameterValues(op)/]);
            System.out.println("     Result: " + result);
            [else]
            [cls.name.toLowerFirst()/].[op.name/]([getDefaultParameterValues(op)/]);
            [/if]
            [/if]
            [/for]
            System.out.println("     ✓ [cls.name/] completed successfully");
            return;
        }
        [/if]
        [/for]
        
        System.out.println("     ⚠ Use case " + useCaseName + " not found");
        
    } catch (Exception e) {
        System.err.println("     ✗ Error executing " + useCaseName + ": " + e.getMessage());
    }
}

/**
 * Execute controller operations
 */
private void executeControllerOperations() {
    [for (cls : Class | model.allOwnedElements()->filter(Class)->select(c | c.name.contains('Controller')))]
    [if (cls.name <> null)]
    System.out.println("Executing [cls.name/] operations:");
    [for (op : Operation | cls.ownedOperation)]
    [if (op.name <> null)]
    try {
        [if (getOperationReturnType(op) <> 'void')]
        [getOperationReturnType(op)/] result = [cls.name.toLowerFirst()/].[op.name/]([getDefaultParameterValues(op)/]);
        System.out.println("  - [op.name/]() returned: " + result);
        [else]
        [cls.name.toLowerFirst()/].[op.name/]([getDefaultParameterValues(op)/]);
        System.out.println("  - [op.name/]() executed");
        [/if]
    } catch (Exception e) {
        System.err.println("  - Error in [op.name/](): " + e.getMessage());
    }
    [/if]
    [/for]
    [/if]
    [/for]
}

[/template]
// Workflow helper methods
private void executeUseCase(String useCaseName) {
    System.out.println(">> Executing Use Case: " + useCaseName);
    // TODO: Implement specific use case logic based on model
}

private void performAction(String actionName) {
    System.out.println(">> Performing Action: " + actionName);
    // TODO: Implement specific action logic
}

private boolean makeDecision(String decisionName) {
    System.out.println(">> Making Decision: " + decisionName);
    // TODO: Implement decision logic based on guards in model
    // For demo purposes, return random boolean
    boolean decision = Math.random() > 0.5;
    System.out.println("   Decision result: " + decision);
    return decision;
}

[/template]

[query public getJavaType(type : Type) : String =
if (type.oclIsUndefined() or type = null) then 'Object'
else if (type.name = 'String') then 'String'
else if (type.name = 'Integer' or type.name = 'int' or type.name = 'EInt') then 'int'
else if (type.name = 'Boolean' or type.name = 'boolean') then 'boolean'
else if (type.name = 'Real' or type.name = 'double') then 'double'
else if (type.name = 'EBigInteger') then 'BigInteger'
else if (type.name = 'void') then 'void'
else if (type.name <> null) then type.name
else 'Object'
endif endif endif endif endif endif endif endif
/]

[query public getDefaultValue(type : Type) : String =
if (type.oclIsUndefined() or type = null) then 'null'
else if (type.name = 'String') then '""'
else if (type.name = 'Integer' or type.name = 'int' or type.name = 'EInt') then '0'
else if (type.name = 'Boolean' or type.name = 'boolean') then 'false'
else if (type.name = 'Real' or type.name = 'double') then '0.0'
else if (type.name = 'EBigInteger') then 'BigInteger.ZERO'
else 'null'
endif endif endif endif endif endif
/]

[query public getOperationReturnType(op : Operation) : String =
if (op.ownedParameter->select(p | p.direction = ParameterDirectionKind::return)->size() > 0) then
    getJavaType(op.ownedParameter->select(p | p.direction = ParameterDirectionKind::return)->first().type)
else if (op.type <> null) then
    getJavaType(op.type)
else
    'void'
endif endif
/]

[query public getOperationParameters(op : Operation) : String =
op.ownedParameter->select(p | p.direction <> ParameterDirectionKind::return)
    ->collect(p | getJavaType(p.type) + ' ' + p.name)
    ->sep(', ')
/]

[query public getDefaultParameterValues(op : Operation) : String =
op.ownedParameter->select(p | p.direction <> ParameterDirectionKind::return)
    ->collect(p | getDefaultValue(p.type))
    ->sep(', ')
/]